#include "../inc/hart_slave_req.h"
#include "../inc/hart_slave_frame.h"

/**
 * @brief 配置次数增加1次
 * @return {*}
 */
void configuration_count_update(void)
{
    (*hart_device_attribute.configuration_update_count)++;
    BIT_SET(hart_device_attribute.device_status.operational_state, DEVICE_OPERATIONAL_STATE_7);
}

static BOOL falsh_write(void)
{
    return hart_storage_write(HART_EEPROM_ADDRESS, (uint8_t *)&hart_device_attribute.flash_variable, sizeof(hart_storage_variable_t));
}

static BOOL falsh_read(void)
{
    return hart_storage_read(HART_EEPROM_ADDRESS, (uint8_t *)&hart_device_attribute.flash_variable, sizeof(hart_storage_variable_t));
}

/**
 * @brief 未定义命令
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_undef_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    resp->code = RESPONSE_COMMUNICATION_CODE_6;
    return TRUE;
}

/**
 * @brief 读取唯一标识命令V5
 * @param {hart_response_t} *resp
 * @return {*}
 */
static void command_0_req(hart_response_t *resp)
{
    *resp->data_p++ = 254;                                                                  // 默认254
    *resp->data_p++ = HI_UINT16(hart_device_attribute.flash_variable.extended_device_type); // 扩展设备类型
    *resp->data_p++ = LO_UINT16(hart_device_attribute.flash_variable.extended_device_type);
    *resp->data_p++ = HART_PREAMBLE_DEFAULT_LEN;                                             // 主设备到从设备的最少同步前导码数量
    *resp->data_p++ = hart_get_current_protocol_version();                                   // 本设备实施的HART协议主要版本号。对于HART版本7。该值必须是数字7
    *resp->data_p++ = hart_device_attribute.flash_variable.device_revision;                  // 设备版本
    *resp->data_p++ = hart_device_attribute.flash_variable.device_software_revision;         // 设备软件版本，254,255保留
    *resp->data_p++ = hart_device_attribute.flash_variable.device_hardware_revision.version; // （高5bits）硬件版本号，31保留;（低3bits）5.10 物理信号
    resp->data_p++;                                                                          // 保留
    osel_memcpy(resp->data_p, hart_device_attribute.flash_variable.long_address + 2, 3);     // 设备ID，长ID的后3个字节
    resp->data_p += 3;
    if (hart_get_current_protocol_version() == HART_PROTOCOL_VERSION_7)
    {
        *resp->data_p++ = hart_device_attribute.flash_variable.s2m_preambles;           // 从设备到主设备的响应前导码个数
        *resp->data_p++ = *hart_device_attribute.last_device_variable;                  // 上一个设备变量，这表示应用程序应在现场设备中找到的最后一个设备变量代码（在执行Command 54时读取设备的变量）
        *resp->data_p++ = HI_UINT16(*hart_device_attribute.configuration_update_count); // 配置被更新的次数
        *resp->data_p++ = LO_UINT16(*hart_device_attribute.configuration_update_count);
        *resp->data_p++ = hart_device_attribute.device_status.additional_device_status.extended_device_status; // 扩展现场设备状态未指定的任何位都是未定义的，必须设置为零。
        *resp->data_p++ = HI_UINT16(hart_device_attribute.flash_variable.manufacturer_identification_code);    // 制造商标识码
        *resp->data_p++ = LO_UINT16(hart_device_attribute.flash_variable.manufacturer_identification_code);
        *resp->data_p++ = HI_UINT16(hart_device_attribute.flash_variable.private_label_distributor_code); // 私有标签分销商代码
        *resp->data_p++ = LO_UINT16(hart_device_attribute.flash_variable.private_label_distributor_code);
        *resp->data_p++ = hart_device_attribute.flash_variable.device_profile; // 设备配置文件
    }
}

/**
 * @brief 读取唯一标识命令V5  2023-05-06
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_0_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    command_0_req(resp);
    return TRUE;
}

/**
 * @brief 读取主变量
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_1_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    float32_u tmp;
    hart_device_variable_t *variable = NULL;
    variable = get_device_variable(DEVICE_VARIABLE_CODE_246);
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }
    osel_memcpy((uint8_t *)&tmp.f, (uint8_t *)variable->value, sizeof(float32));
    tmp.c = S2B_UINT32(tmp.c);
    *resp->data_p++ = variable->units_code;                        // 主变量单位代码
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u)); // 主要变量
    resp->data_p += sizeof(float32_u);
    return TRUE;
}

/**
 * @brief    读取主变量的回路电流和量程百分比
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_2_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    float32_u tmp;
    hart_device_variable_t *variable = NULL;
    variable = get_device_variable(DEVICE_VARIABLE_CODE_245); // 回路电流
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }
    osel_memcpy((uint8_t *)&tmp.f, (uint8_t *)variable->value, sizeof(float32));
    tmp.c = S2B_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);

    variable = get_device_variable(DEVICE_VARIABLE_CODE_244); // 百分百
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }
    osel_memcpy((uint8_t *)&tmp.f, (uint8_t *)variable->value, sizeof(float32));
    tmp.c = S2B_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);

    return TRUE;
}

/**
 * @brief    读取动态变量和回路电流
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_3_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    float32_u tmp;
    hart_device_variable_t *variable = NULL;
    variable = get_device_variable(DEVICE_VARIABLE_CODE_245); // 回路电流
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }
    osel_memcpy((uint8_t *)&tmp.f, (uint8_t *)variable->value, sizeof(float32));
    tmp.c = S2B_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);

    /**
     * 响应数据在每个设备类型支持的最后一个动态变量之后被截断（请参见表1）对于给定的设备类型和设备版本，响应数据字节数必须是固定的。换句话说，一个设备类型可能在一种操作模式下不返回PV、SV和TV，后来（在不同的操作中）只返回PV和SV。返回的动态变量数可能随着设备版本的增加而增加。返回的动态变量的数量永远不会减少
     */
    variable = get_device_variable(DEVICE_VARIABLE_CODE_246); // 主变量
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        return TRUE;
    }
    osel_memcpy((uint8_t *)&tmp.f, (uint8_t *)variable->value, sizeof(float32));
    tmp.c = S2B_UINT32(tmp.c);
    *resp->data_p++ = variable->units_code;
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);

    variable = get_device_variable(DEVICE_VARIABLE_CODE_247); // 次要变量
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        return TRUE;
    }
    osel_memcpy((uint8_t *)&tmp.f, (uint8_t *)variable->value, sizeof(float32));
    tmp.c = S2B_UINT32(tmp.c);
    *resp->data_p++ = variable->units_code;
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);

    variable = get_device_variable(DEVICE_VARIABLE_CODE_248); // 三级变量
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        return TRUE;
    }
    osel_memcpy((uint8_t *)&tmp.f, (uint8_t *)variable->value, sizeof(float32));
    tmp.c = S2B_UINT32(tmp.c);
    *resp->data_p++ = variable->units_code;
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);

    variable = get_device_variable(DEVICE_VARIABLE_CODE_249); // 四级变量
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        return TRUE;
    }
    osel_memcpy((uint8_t *)&tmp.f, (uint8_t *)variable->value, sizeof(float32));
    tmp.c = S2B_UINT32(tmp.c);
    *resp->data_p++ = variable->units_code;
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);
    return TRUE;
}

/**
 * @brief   写入轮训地址V5  2023-05-08
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_6_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    hart_device_attribute.flash_variable.poll_address = req->data.command_6.poll_address;
    if (hart_get_current_protocol_version() == HART_PROTOCOL_VERSION_7)
    {
        hart_device_attribute.flash_variable.loop_current_mode = req->data.command_6.loop_current_mode;
    }

    configuration_count_update();

    *resp->data_p++ = hart_device_attribute.flash_variable.poll_address;
    if (hart_get_current_protocol_version() == HART_PROTOCOL_VERSION_7)
    {
        *resp->data_p++ = hart_device_attribute.flash_variable.loop_current_mode;
    }
    return TRUE;
}

/**
 * @brief  读取循环配置  2023-05-08
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
// static BOOL hart_slave_command_7_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     *resp->data_p++ = hart_device_attribute.flash_variable.poll_address;      // 轮询地址
//     *resp->data_p++ = hart_device_attribute.flash_variable.loop_current_mode; // 回路电流模式
//     return TRUE;
// }

/**
 * @brief 读取动态变量分类  2023-05-08
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_8_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    hart_device_variable_t *variable = NULL;
    variable = get_device_variable(DEVICE_VARIABLE_CODE_246); // 主变量
    *resp->data_p++ = variable->classification;
    variable = get_device_variable(DEVICE_VARIABLE_CODE_247); // 主变量
    *resp->data_p++ = variable->classification;
    variable = get_device_variable(DEVICE_VARIABLE_CODE_248); // 主变量
    *resp->data_p++ = variable->classification;
    variable = get_device_variable(DEVICE_VARIABLE_CODE_249); // 主变量
    *resp->data_p++ = variable->classification;
    return TRUE;
}

/**
 * @brief 读取具有状态的设备变量  2023-05-08
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
// static BOOL hart_slave_command_9_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     hart_device_variable_t *variable = NULL;
//     slot_device_variable_rsp_t slot;
//     hart_command_9_rsp_t rsp;
//     float32_u tmp;
//     uint8_t *code = NULL;
//     osel_memset((uint8_t *)&rsp, 0, sizeof(hart_command_9_rsp_t));
//     rsp.extended_field_device_status = hart_device_attribute.device_status.additional_device_status.extended_device_status; // 扩展现场设备状态
//     for (uint8_t i = 0; i < HART_SOLT_DEVICE_VARIABLE_LEN; i++)
//     {
//         code = (uint8_t *)(&req->data.command_9.hart_command_9_req.slot0) + i;
//         variable = get_device_variable(*code);
//         osel_memset((uint8_t *)&slot, 0, sizeof(slot_device_variable_rsp_t));
//         slot.code = variable->code;
//         slot.classification = variable->classification;
//         slot.units_code = variable->units_code;
//         osel_memcpy((uint8_t *)&tmp.f, (uint8_t *)variable->value, sizeof(float32));
//         tmp.c = S2B_UINT32(tmp.c);
//         slot.value.f = tmp.f;
//         slot.status = variable->status.data;

//         osel_memcpy((uint8_t *)&rsp.slot[i], (uint8_t *)&slot, sizeof(slot_device_variable_rsp_t));
//     }
//     rsp.slot_data_timestamp = rtc_to_timestamp();
//     rsp.slot_data_timestamp = S2B_UINT32(rsp.slot_data_timestamp);
//     osel_memcpy(resp->data_p, (uint8_t *)&rsp, sizeof(hart_command_9_rsp_t));
//     resp->data_p += sizeof(hart_command_9_rsp_t);
//     return TRUE;
// }

/**
 * @brief 读取与标签关联的唯一标识符  2023-05-08
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
// static BOOL hart_slave_command_11_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     BOOL same = TRUE;
//     for (uint8_t i = 0; i < HART_PACKED6_LEN; i++)
//     {
//         if (req->data.command_11.tag[i] != hart_device_attribute.flash_variable.tag[i])
//         {
//             same = FALSE;
//             break;
//         }
//     }

//     if (same)
//     {
//         command_0_req(resp);
//     }
//     else
//     {
//         resp->code = RESPONSE_COMMUNICATION_CODE_38;
//     }
//     return TRUE;
// }

/**
 * @brief 读取消息   2023-05-08
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_12_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    uint8_t buf[HART_PACKED32_LEN];
    osel_memset(buf, 0x00, HART_PACKED32_LEN);
    encode_ascii_6(hart_device_attribute.flash_variable.message, HART_PACKED32_LEN, buf);
    for (uint8_t i = 0; i < HART_PACKED24_LEN; i++)
    {
        *resp->data_p++ = buf[i];
    }
    return TRUE;
}

/**
 * @brief  读取标签、描述符、日期 2023-05-08
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_13_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    uint8_t buf[HART_PACKED24_LEN];
    osel_memset(buf, 0x00, HART_PACKED24_LEN);
    encode_ascii_6(hart_device_attribute.flash_variable.tag, HART_PACKED8_LEN, buf);
    // LOG_HEX(hart_device_attribute.flash_variable.tag, HART_PACKED8_LEN);
    // LOG_HEX(buf, HART_PACKED8_LEN);
    for (uint8_t i = 0; i < HART_PACKED6_LEN; i++)
    {
        *resp->data_p++ = buf[i]; // 标签
    }

    osel_memset(buf, 0x00, HART_PACKED24_LEN);
    encode_ascii_6(hart_device_attribute.flash_variable.descriptor, HART_PACKED16_LEN, buf);
    // LOG_HEX(hart_device_attribute.flash_variable.descriptor, HART_PACKED16_LEN);
    // LOG_HEX(buf, HART_PACKED16_LEN);
    for (uint8_t i = 0; i < HART_PACKED12_LEN; i++)
    {
        *resp->data_p++ = buf[i]; // 描述符
    }
    for (uint8_t i = 0; i < HART_DATE_LEN; i++)
    {
        *resp->data_p++ = hart_device_attribute.flash_variable.date[i];
    }
    return TRUE;
}

/**
 * @brief 读取主变量传感器信息 2023-05-08
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
// static BOOL hart_slave_command_14_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     hart_command_14_t data;
//     hart_device_variable_t *variable = NULL;
//     variable = get_device_variable(DEVICE_VARIABLE_CODE_246); // 主变量
//     if (variable->code == DEVICE_VARIABLE_CODE_250)
//     {
//         resp->code = RESPONSE_COMMUNICATION_CODE_16;
//         return TRUE;
//     }
//     osel_memcpy(data.pv_transducer_serial_number.bs, variable->transducer.serial_number.bs, sizeof(uint24_t));
//     data.pv_transducer_limits_and_minimum_span_units_code = variable->transducer.limits_and_minimum_span_units_code;
//     data.pv_upper_transducer_limit = variable->transducer.upper_limit;
//     data.pv_lower_transducer_limit = variable->transducer.lower_limit;
//     data.pv_minimum_span = variable->transducer.minimum_span;

//     data.pv_upper_transducer_limit.c = S2B_UINT32(data.pv_upper_transducer_limit.c); // 主变量上限
//     data.pv_lower_transducer_limit.c = S2B_UINT32(data.pv_lower_transducer_limit.c); // 主变量下限
//     data.pv_minimum_span.c = S2B_UINT32(data.pv_minimum_span.c);                     // 主变量最小跨度

//     osel_memcpy(resp->data_p, (uint8_t *)&data, sizeof(hart_command_14_t)); // 主变量传感器信息
//     resp->data_p += sizeof(hart_command_14_t);
//     return TRUE;
// }

/**
 * @brief 读取设备信息 2023-05-09
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_15_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    hart_device_variable_t *variable = NULL;
    hart_command_15_t data;
    variable = get_device_variable(DEVICE_VARIABLE_CODE_246); // 主变量
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }

    data.pv_alarm_selection_code = variable->attribute.alarm_selection_code;
    data.pv_transfer_function_code = variable->attribute.transfer_function_code;
    data.pv_upper_and_lower_range_values_units_code = variable->attribute.upper_and_lower_range_values_units_code;
    data.pv_damping_value.f = variable->attribute.damping_value;
    data.pv_upper_range_value.f = variable->attribute.upper_range_value;
    data.pv_lower_range_value.f = variable->attribute.lower_range_value;
    data.pv_upper_range_value.c = S2B_UINT32(data.pv_upper_range_value.c); // 主变量上限
    data.pv_lower_range_value.c = S2B_UINT32(data.pv_lower_range_value.c); // 主变量下限
    data.pv_damping_value.c = S2B_UINT32(data.pv_damping_value.c);         // 主变量阻尼

    data.write_protect_code = hart_device_attribute.flash_variable.write_protect_code;
    data.reserved = 250;
    data.pv_analog_channel_flags = variable->attribute.analog_channel_flags;
    osel_memcpy(resp->data_p, (uint8_t *)&data, sizeof(hart_command_15_t)); // 设备信息
    resp->data_p += sizeof(hart_command_15_t);
    return TRUE;
}

/**
 * @brief 读取最终总装编号 2023-05-09
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
// static BOOL hart_slave_command_16_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     osel_memcpy(resp->data_p, hart_device_attribute.flash_variable.final_assembly_number, HART_PACKED3_LEN); // 最终总装编号
//     resp->data_p += sizeof(uint24_t);
//     return TRUE;
// }

/**
 * @brief 写入消息V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_17_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    uint8_t buf[HART_PACKED32_LEN];
    if (req->data_length < HART_PACKED24_LEN)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    osel_memset(buf, 0x00, HART_PACKED32_LEN);
    osel_memset(hart_device_attribute.flash_variable.message, 0x00, HART_PACKED32_LEN);

    decode_ascii_6(req->data.command_17.message, HART_PACKED24_LEN, buf);
    osel_memcpy(hart_device_attribute.flash_variable.message, buf, HART_PACKED24_LEN);

    configuration_count_update();

    // 回复数据
    osel_memset(buf, 0x20, HART_PACKED32_LEN);
    encode_ascii_6(hart_device_attribute.flash_variable.message, HART_PACKED32_LEN, buf);
    osel_memcpy(resp->data_p, buf, HART_PACKED24_LEN);
    resp->data_p += HART_PACKED24_LEN;

    return TRUE;
}

/**
 * @brief 写标签、描述符、日期V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_18_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    uint8_t buf[HART_PACKED24_LEN];
    if (req->data_length < (HART_PACKED6_LEN + HART_PACKED12_LEN + HART_DATE_LEN))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    osel_memset(buf, 0x00, HART_PACKED24_LEN);
    osel_memset(hart_device_attribute.flash_variable.tag, 0x00, HART_PACKED8_LEN);
    decode_ascii_6(req->data.command_18.tag, HART_PACKED6_LEN, buf);
    osel_memcpy(hart_device_attribute.flash_variable.tag, buf, HART_PACKED8_LEN); // 更新标签

    osel_memset(buf, 0x00, HART_PACKED24_LEN);
    osel_memset(hart_device_attribute.flash_variable.descriptor, 0x00, HART_PACKED16_LEN);
    decode_ascii_6(req->data.command_18.descriptor, HART_PACKED12_LEN, buf);
    osel_memcpy(hart_device_attribute.flash_variable.descriptor, buf, HART_PACKED16_LEN); // 更新描述符

    osel_memset(hart_device_attribute.flash_variable.date, 0x00, HART_DATE_LEN);
    osel_memcpy(hart_device_attribute.flash_variable.date, req->data.command_18.date, HART_DATE_LEN); // 更新日期

    configuration_count_update();

    // 回复数据
    osel_memset(buf, 0x20, HART_PACKED24_LEN);
    encode_ascii_6(hart_device_attribute.flash_variable.tag, HART_PACKED8_LEN, buf);
    osel_memcpy(resp->data_p, buf, HART_PACKED6_LEN); // 标签
    resp->data_p += HART_PACKED6_LEN;

    osel_memset(buf, 0x20, HART_PACKED24_LEN);
    encode_ascii_6(hart_device_attribute.flash_variable.descriptor, HART_PACKED16_LEN, buf);
    osel_memcpy(resp->data_p, buf, HART_PACKED12_LEN); // 描述符
    resp->data_p += HART_PACKED12_LEN;

    osel_memcpy(resp->data_p, hart_device_attribute.flash_variable.date, HART_DATE_LEN); // 日期
    resp->data_p += HART_DATE_LEN;

    return TRUE;
}

/**
 * @brief 编写总装编号V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
// static BOOL hart_slave_command_19_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     if (req->data_length < HART_PACKED3_LEN)
//     {
//         resp->code = RESPONSE_COMMUNICATION_CODE_5;
//         return TRUE;
//     }
//     osel_memset(hart_device_attribute.flash_variable.final_assembly_number, 0x00, HART_PACKED3_LEN);
//     osel_memcpy(hart_device_attribute.flash_variable.final_assembly_number, req->data.command_19.final_assembly_number, HART_PACKED3_LEN); // 更新总装编号

//     configuration_count_update();

//     // 回复数据
//     osel_memcpy(resp->data_p, hart_device_attribute.flash_variable.final_assembly_number, HART_PACKED3_LEN);
//     resp->data_p += HART_PACKED3_LEN;
//     return TRUE;
// }

/**
 * @brief 读取长标签
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_20_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    osel_memcpy(resp->data_p, hart_device_attribute.flash_variable.long_tag, HART_PACKED32_LEN); // 长标签
    resp->data_p += HART_PACKED32_LEN;
    return TRUE;
}

/**
 * @brief 读取与长标签关联的唯一标识符
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_21_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    BOOL same = TRUE;
    for (uint8_t i = 0; i < HART_PACKED32_LEN; i++)
    {
        if (req->data.command_21.long_tag[i] != hart_device_attribute.flash_variable.long_tag[i])
        {
            same = FALSE;
            break;
        }
    }

    if (same)
    {
        command_0_req(resp);
    }
    else
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_38;
    }
    return TRUE;
}

/**
 * @brief 写长标签
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_22_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (req->data_length < HART_PACKED32_LEN)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    osel_memset(hart_device_attribute.flash_variable.long_tag, 0x00, HART_PACKED32_LEN);
    osel_memcpy(hart_device_attribute.flash_variable.long_tag, req->data.command_22.long_tag, HART_PACKED32_LEN); // 更新长标签

    configuration_count_update();

    // 回复数据
    osel_memcpy(resp->data_p, hart_device_attribute.flash_variable.long_tag, HART_PACKED32_LEN);
    resp->data_p += HART_PACKED32_LEN;
    return TRUE;
}

/**
 * @brief 重置配置更改标志
 * 配置恢复，配置更改在未写入到EEPROM中是先存在RAM中。command6等写入指令会更新计数器，通过计数器的数值不同来判断配置是否更新
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_38_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (req->data_length < sizeof(uint16_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    uint16_t configuration_change_counter = B2S_UINT16(req->data.command_38.configuration_change_counter);
    if (configuration_change_counter != *hart_device_attribute.configuration_update_count)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_9;
        return TRUE;
    }

    // 将配置从falsh中重新读取到缓存
    if (FALSE == hart_storage_read(HART_EEPROM_ADDRESS, (uint8_t *)&hart_device_attribute.flash_variable, sizeof(hart_storage_variable_t)))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_16;
    }
    else
    {
        *resp->data_p++ = HI_UINT16(configuration_change_counter);
        *resp->data_p++ = LO_UINT16(configuration_change_counter);
        BIT_CLR(hart_device_attribute.device_status.operational_state, DEVICE_OPERATIONAL_STATE_7);
    }
    return TRUE;
}

/**
 * @brief 读取其他设备状态
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_48_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    additional_device_status_t command_48;
    uint8_t *ptr = NULL;
    osel_memset((uint8_t *)&command_48, 0x00, sizeof(additional_device_status_t));
    ptr = command_48.device_specific_status;
    for (uint8_t i = 0; i < 6; i++)
    {
        *ptr = hart_device_attribute.device_status.additional_device_status.device_specific_status[i];
    }

    ptr = &command_48.extended_device_status;
    *ptr = hart_device_attribute.device_status.additional_device_status.extended_device_status;
    ptr++;
    *ptr = hart_device_attribute.device_status.additional_device_status.device_operating_mode;
    ptr++;
    *ptr = hart_device_attribute.device_status.additional_device_status.standardized_status0;
    ptr++;
    *ptr = hart_device_attribute.device_status.additional_device_status.standardized_status1;
    ptr++;
    *ptr = hart_device_attribute.device_status.additional_device_status.analog_channel_saturated;
    ptr++;
    *ptr = hart_device_attribute.device_status.additional_device_status.standardized_status2;
    ptr++;
    *ptr = hart_device_attribute.device_status.additional_device_status.standardized_status3;
    ptr++;
    *ptr = hart_device_attribute.device_status.additional_device_status.analog_channel_fixed;
    ptr++;

    ptr = command_48.extended_device_specific_status;
    for (uint8_t i = 0; i < 11; i++)
    {
        *ptr = hart_device_attribute.device_status.additional_device_status.extended_device_specific_status[i];
    }

    // 回复数据
    osel_memcpy(resp->data_p, (uint8_t *)&command_48, sizeof(additional_device_status_t));
    resp->data_p += sizeof(additional_device_status_t);
    return TRUE;
}

// 通用命令

/**
 * @brief 读取设备变量V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_33_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    uint8_t *code = NULL;
    hart_device_variable_t *variable = NULL;
    float32_u tmp;
    if (req->data_length == 0)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }

    code = (uint8_t *)&req->data.command_33;
    for (uint8_t i = 0; i < req->data_length; i++)
    {
        variable = get_device_variable(*code);
        osel_memcpy((uint8_t *)&tmp.f, (uint8_t *)variable->value, sizeof(float32));
        tmp.c = S2B_UINT32(tmp.c);
        *resp->data_p++ = variable->code;
        *resp->data_p++ = variable->units_code;
        osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
        resp->data_p += sizeof(float32_u);
        code++;
    }
    return TRUE;
}

#if 0
/**
 * @brief 写入主变量阻尼值V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_34_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    float32_u tmp;
    hart_device_variable_t *variable = NULL;
    if (req->data_length < sizeof(hart_command_34_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    variable = get_device_variable(DEVICE_VARIABLE_CODE_246); // 主变量
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }

    tmp.f = req->data.command_34.pv_damping_value;
    tmp.c = B2S_UINT32(tmp.c);
    variable->attribute.damping_value = tmp.f;
    configuration_count_update();
    tmp.f = variable->attribute.damping_value;
    tmp.c = S2B_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);
    return TRUE;
}

/**
 * @brief 写入主变量范围值V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_35_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    hart_device_variable_t *variable = NULL;
    float32_u tmp;
    if (req->data_length < sizeof(hart_command_35_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    variable = get_device_variable(DEVICE_VARIABLE_CODE_246); // 主变量
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_2;
        return TRUE;
    }
    variable->attribute.upper_and_lower_range_values_units_code = req->data.command_35.pv_upper_and_lower_range_values_units_code;
    tmp.f = req->data.command_35.pv_upper_range_value;
    tmp.c = B2S_UINT32(tmp.c);
    variable->attribute.upper_range_value = tmp.f;
    tmp.f = req->data.command_35.pv_lower_range_value;
    tmp.c = B2S_UINT32(tmp.c);
    variable->attribute.lower_range_value = tmp.f;

    configuration_count_update();

    // 回复数据
    *resp->data_p++ = variable->attribute.upper_and_lower_range_values_units_code;
    tmp.f = variable->attribute.upper_range_value;
    tmp.c = S2B_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);

    tmp.f = variable->attribute.lower_range_value;
    tmp.c = S2B_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);
    return TRUE;
}

/**
 * @brief 设置主变量上限值V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_36_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    hart_device_variable_t *variable = NULL;
    variable = get_device_variable(DEVICE_VARIABLE_CODE_246); // 主变量
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }
    osel_memcpy((uint8_t *)variable->value, (uint8_t *)&variable->attribute.upper_range_value, sizeof(float32)); // 将主要变量上限值复制到主变量
    configuration_count_update();
    return TRUE;
}

/**
 * @brief 设置主变量下限值V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_37_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    hart_device_variable_t *variable = NULL;
    variable = get_device_variable(DEVICE_VARIABLE_CODE_246); // 主变量
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }
    osel_memcpy((uint8_t *)variable->value, (uint8_t *)&variable->attribute.lower_range_value, sizeof(float32)); // 将主要变量下限值复制到主变量
    configuration_count_update();
    return TRUE;
}


/**
 * @brief 进入/退出固定电流模式V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_40_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    float32_u tmp;
    if (req->data_length < sizeof(hart_command_40_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    tmp.f = req->data.command_40.pv_fixed_current_level;
    tmp.c = B2S_UINT32(tmp.c);
    hart_device_attribute.pv_fixed_current_level = tmp.f;

    // 回复数据
    tmp.f = *hart_device_attribute.actual_pv_current_level;
    tmp.c = S2B_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);
    return TRUE;
}

/**
 * @brief 设置主变量零V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_43_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    hart_device_variable_t *variable = NULL;
    variable = get_device_variable(DEVICE_VARIABLE_CODE_246); // 主变量
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }
    *variable->value = 0;
    return TRUE;
}

/**
 * @brief 编写主变量单元V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_44_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    hart_device_variable_t *variable = NULL;
    variable = get_device_variable(DEVICE_VARIABLE_CODE_246); // 主变量
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }
    variable->units_code = req->data.command_44.pv_units_code;
    configuration_count_update();
    // 回复数据
    *resp->data_p++ = variable->units_code;
    return TRUE;
}

/**
 * @brief 微调回路电流归零V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_45_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    float32_u tmp;
    if (req->data_length < sizeof(hart_command_45_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    hart_device_variable_t *variable = NULL;
    variable = get_device_variable(DEVICE_VARIABLE_CODE_245); // 回路电流
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }
    tmp.f = req->data.command_45.pv_loop_current_level;
    tmp.c = B2S_UINT32(tmp.c);
    hart_device_attribute.pv_loop_current_level = tmp.f;

    // 回复数据
    tmp.f = *variable->value;
    tmp.c = S2B_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);
    return TRUE;
}

/**
 * @brief 微调回路电流增益V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_46_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    float32_u tmp;
    if (req->data_length < sizeof(hart_command_46_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    hart_device_variable_t *variable = NULL;
    variable = get_device_variable(DEVICE_VARIABLE_CODE_245); // 回路电流
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }
    tmp.f = req->data.command_46.pv_loop_current_level;
    tmp.c = B2S_UINT32(tmp.c);
    hart_device_attribute.pv_loop_current_level = tmp.f;

    // 回复数据
    tmp.f = *variable->value;
    tmp.c = S2B_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);
    return TRUE;
}

/**
 * @brief 编写主变量传递函数V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_47_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    hart_device_variable_t *variable = NULL;
    if (req->data_length < sizeof(hart_command_47_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }

    variable = get_device_variable(DEVICE_VARIABLE_CODE_246); // 主变量
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }
    variable->attribute.transfer_function_code = req->data.command_47.pv_transfer_function_code;
    configuration_count_update();
    // 回复数据
    *resp->data_p++ = variable->attribute.transfer_function_code;
    return TRUE;
}

/**
 * @brief 写入主变量传感器序列号V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_49_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    hart_device_variable_t *variable = NULL;
    if (req->data_length < sizeof(hart_command_49_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    variable = get_device_variable(DEVICE_VARIABLE_CODE_246); // 主变量
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }
    osel_memcpy(variable->transducer.serial_number.bs, req->data.command_49.pv_transducer_serial_number.bs, sizeof(uint24_t));
    configuration_count_update();
    osel_memcpy(resp->data_p, variable->transducer.serial_number.bs, sizeof(uint24_t));
    resp->data_p += sizeof(uint24_t);
    return TRUE;
}

/**
 * @brief 读取动态变量赋值V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_50_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    hart_device_variable_t *variable = NULL;
    variable = get_device_variable(DEVICE_VARIABLE_CODE_246); // 主变量
    *resp->data_p++ = variable->dynamic_variable_code;
    variable = get_device_variable(DEVICE_VARIABLE_CODE_247); // 次要变量
    *resp->data_p++ = variable->dynamic_variable_code;
    variable = get_device_variable(DEVICE_VARIABLE_CODE_248); // 第三变量
    *resp->data_p++ = variable->dynamic_variable_code;
    variable = get_device_variable(DEVICE_VARIABLE_CODE_249); // 第四变量
    *resp->data_p++ = variable->dynamic_variable_code;
    return TRUE;
}

/**
 * @brief 编写动态变量赋值V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_51_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (req->data_length == 0)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    hart_device_variable_t *variable = NULL;
    uint8_t *ptr = NULL;
    uint8_t invalid_selection[] = {DEVICE_VARIABLE_CODE_244, DEVICE_VARIABLE_CODE_245, DEVICE_VARIABLE_CODE_246, DEVICE_VARIABLE_CODE_247,
                                   DEVICE_VARIABLE_CODE_248, DEVICE_VARIABLE_CODE_249};
    uint8_t device_variables[4];
    osel_memset(device_variables, DEVICE_VARIABLE_CODE_250, ARRAY_LEN(device_variables));
    for (uint8_t i = 0; i < req->data_length; i++)
    {
        ptr = (uint8_t *)&req->data.command_51.device_ariables[i];
        // 设备变量代码244-249是无效的选择
        if (TRUE == is_in_array((uint16_t *)invalid_selection, ARRAY_LEN(invalid_selection), *ptr))
        {
            resp->code = RESPONSE_COMMUNICATION_CODE_2;
            return TRUE;
        }
        else
        {
            device_variables[i] = *ptr;
        }
    }

    // 更新动态变量赋值
    /* The above code is iterating through an array of device variables and setting their dynamic variable
    codes based on their position in the array. It uses a switch statement to determine which device
    variable to set and then adds the dynamic variable code to a response data buffer. */
    for (uint8_t i = 0; i < ARRAY_LEN(device_variables); i++)
    {

        switch (i)
        {
        case 0:
            variable = get_device_variable(DEVICE_VARIABLE_CODE_246); // 主变量
            variable->dynamic_variable_code = device_variables[i];
            break;
        case 1:
            variable = get_device_variable(DEVICE_VARIABLE_CODE_247); // 次要变量
            variable->dynamic_variable_code = device_variables[i];
            break;
        case 2:
            variable = get_device_variable(DEVICE_VARIABLE_CODE_248); // 第三变量
            variable->dynamic_variable_code = device_variables[i];
            break;
        case 3:
            variable = get_device_variable(DEVICE_VARIABLE_CODE_249); // 第四变量
            variable->dynamic_variable_code = device_variables[i];
            break;
        default:
            continue;
            ;
        }
        *resp->data_p++ = variable->dynamic_variable_code;
    }
    configuration_count_update();
    return TRUE;
}

/**
 * @brief 设置设备变量零V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_52_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    hart_device_variable_t *hart_device_variable_p = NULL;
    BOOL find = FALSE;
    if (req->data_length < sizeof(hart_command_52_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5; // 无效的数据长度
        return TRUE;
    }

    /* The above code is iterating through an array of HART device variables and checking if the code of
    each variable matches a specific device variable code provided in the request data. If a match is
    found, the value of that device variable is set to 0 and the loop is exited. */
    for (uint8_t i = 0; i < HART_DEVICE_VARIABLE_LEN; i++)
    {
        hart_device_variable_p = &hart_device_attribute.flash_variable.device_variable[i];
        if (hart_device_variable_p->code == req->data.command_52.device_ariable)
        {
            *hart_device_variable_p->value = 0;
            find = TRUE;
            break;
        }
    }

    // 回复数据
    if (FALSE == find)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_2; // 无效的设备变量代码
        return TRUE;
    }
    else
    {
        *resp->data_p++ = hart_device_variable_p->code; // 设备变量代码
    }

    return TRUE;
}

/**
 * @brief 写入设备变量单位V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_53_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    hart_device_variable_t *hart_device_variable_p = NULL;
    BOOL find = FALSE;
    if (req->data_length < sizeof(hart_command_53_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    for (uint8_t i = 0; i < HART_DEVICE_VARIABLE_LEN; i++)
    {
        hart_device_variable_p = &hart_device_attribute.flash_variable.device_variable[i];
        if (hart_device_variable_p->code == req->data.command_53.device_ariable)
        {
            hart_device_variable_p->units_code = req->data.command_53.device_ariable_unit_code;
            find = TRUE;
            break;
        }
    }
    // 回复数据
    if (FALSE == find)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_11; // 无效的设备变量代码
        return TRUE;
    }
    else
    {
        *resp->data_p++ = hart_device_variable_p->code;       // 设备变量代码
        *resp->data_p++ = hart_device_variable_p->units_code; // 设备变量单位代码
        configuration_count_update();
    }
    return TRUE;
}

/**
 * @brief 读取设备变量信息V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_54_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    hart_device_variable_t *hart_device_variable_p = NULL;
    float32_u tmp;
    uint32_t acquisition_period = 0;
    if (req->data_length < sizeof(hart_command_54_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    hart_device_variable_p = get_device_variable(req->data.command_54.device_ariable);
    if (hart_device_variable_p->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_2;
        return TRUE;
    }
    hart_device_attribute.last_device_variable = hart_device_variable_p->code;

    // 回复数据
    *resp->data_p++ = hart_device_variable_p->code;                                                   // 设备变量代码
    osel_memcpy(resp->data_p, hart_device_variable_p->transducer.serial_number.bs, sizeof(uint24_t)); // 设备可变传感器序列号
    resp->data_p += sizeof(uint24_t);
    *resp->data_p++ = hart_device_variable_p->transducer.limits_and_minimum_span_units_code; // 设备变量限制/最小量程单位代码

    // 设备变量传感器上限
    tmp.f = hart_device_variable_p->transducer.upper_limit.f;
    tmp.c = S2B_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);
    // 装置可变传感器下限
    tmp.f = hart_device_variable_p->transducer.lower_limit.f;
    tmp.c = S2B_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);
    // 设备可变阻尼值
    tmp.f = hart_device_variable_p->attribute.damping_value;
    tmp.c = S2B_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);

    // 设备变量最小量程
    tmp.f = hart_device_variable_p->transducer.minimum_span.f;
    tmp.c = S2B_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);

    if (hart_get_current_protocol_version() == HART_PROTOCOL_VERSION_7)
    {
        *resp->data_p++ = hart_device_variable_p->classification; // 设备变量分类
        *resp->data_p++ = hart_device_variable_p->family;         // 设备变量系列

        acquisition_period = hart_device_variable_p->acquisition_period;
        acquisition_period = S2B_UINT32(acquisition_period);
        osel_memcpy(resp->data_p, (uint8_t *)&acquisition_period, sizeof(uint32_t)); // 采集周期，表示设备变量更新之间的最长周期
        resp->data_p += sizeof(uint32_t);

        *resp->data_p++ = hart_device_variable_p->properties; // 设备变量属性
    }
    return TRUE;
}

/**
 * @brief 写入设备可变阻尼值V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_55_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    float32_u tmp;
    if (req->data_length < sizeof(hart_command_55_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    hart_device_variable_t *variable = NULL;
    variable = get_device_variable(req->data.command_55.device_ariable);
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_2;
        return TRUE;
    }
    tmp.f = req->data.command_55.damping_value;
    tmp.c = B2S_UINT32(tmp.c);
    variable->attribute.damping_value = tmp.f;
    configuration_count_update();
    // 回复数据
    *resp->data_p++ = variable->code; // 设备变量代码
    tmp.f = variable->attribute.damping_value;
    tmp.c = S2B_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u)); // 设备可变阻尼值
    resp->data_p += sizeof(float32_u);
    return TRUE;
}

/**
 * @brief 写入设备可变传感器序列号V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_56_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (req->data_length < sizeof(hart_command_56_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    hart_device_variable_t *variable = NULL;
    variable = get_device_variable(req->data.command_56.device_ariable);
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_2;
        return TRUE;
    }
    osel_memcpy(variable->transducer.serial_number.bs, req->data.command_56.serial_number.bs, sizeof(uint24_t));
    configuration_count_update();
    // 回复数据
    *resp->data_p++ = variable->code;                                                   // 设备变量代码
    osel_memcpy(resp->data_p, variable->transducer.serial_number.bs, sizeof(uint24_t)); // 设备可变传感器序列号
    resp->data_p += sizeof(uint24_t);
    return TRUE;
}

/**
 * @brief 读取单位标签、描述符、日期V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_57_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    osel_memcpy(resp->data_p, (uint8_t *)&hart_device_attribute.flash_variable.unit_device, sizeof(unit_device_t));
    resp->data_p += sizeof(unit_device_t);
    return TRUE;
}

/**
 * @brief 编写单位标签、描述符、日期V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_58_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (req->data_length < sizeof(hart_command_58_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    osel_memcpy((uint8_t *)&hart_device_attribute.flash_variable.unit_device, (uint8_t *)&req->data.command_58, sizeof(hart_command_58_t));
    configuration_count_update();
    osel_memcpy(resp->data_p, (uint8_t *)&hart_device_attribute.flash_variable.unit_device, sizeof(unit_device_t));
    resp->data_p += sizeof(unit_device_t);
    return TRUE;
}

/**
 * @brief 写入响应序码数V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_59_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (req->data_length < sizeof(hart_command_59_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    if (req->data.command_59.s2m_preambles < 5)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_4;
        return TRUE;
    }
    else if (req->data.command_59.s2m_preambles > 20)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_3;
        return TRUE;
    }
    else
    {
        hart_device_attribute.flash_variable.s2m_preambles = req->data.command_59.s2m_preambles;
        configuration_count_update();
        *resp->data_p++ = hart_device_attribute.flash_variable.s2m_preambles;
    }

    return TRUE;
}

/**
 * @brief 读取模拟通道和范围百分比V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_60_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    float32_u tmp;
    analog_channel_t *analog_channel = NULL;
    if (req->data_length < sizeof(hart_command_60_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    analog_channel = get_analog_channel((analog_channel_number_codes_e)req->data.command_60.analog_channel_number_code);
    if (analog_channel == NULL)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_2;
        return TRUE;
    }

    /* The above code is writing data to a response buffer. It is taking values from an analog channel
        structure (code, units_code, level, percent_range) and converting them to a byte representation
        using a union (tmp). The byte representation is then copied to the response buffer using memcpy. The
        response buffer pointer is incremented after each write to ensure that the next write goes to the
        correct location in the buffer. */
    *resp->data_p++ = analog_channel->code;
    *resp->data_p++ = analog_channel->units_code;

    tmp.f = analog_channel->level.f;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);

    tmp.f = analog_channel->percent_range.f;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);

    return TRUE;
}

/**
 * @brief读取动态变量和主变量模拟通道V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_61_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    float32_u tmp;
    hart_device_variable_t *variable = NULL;
    analog_channel_t *analog_channel = get_analog_channel(ANALOG_CHANNEL_NUMBER_CODES_0);
    if (analog_channel == NULL)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }
    *resp->data_p++ = analog_channel->units_code; // 主要模拟通道单元代码

    tmp.f = analog_channel->level.f;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u)); // 主要可变模拟电平
    resp->data_p += sizeof(float32_u);

    variable = get_device_variable(DEVICE_VARIABLE_CODE_246);
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }
    *resp->data_p++ = variable->units_code; // 主要变量单元代码
    tmp.f = *variable->value;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u)); // 主要变量值
    resp->data_p += sizeof(float32_u);

    variable = get_device_variable(DEVICE_VARIABLE_CODE_247);
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }
    *resp->data_p++ = variable->units_code; //  次要变量单元代码
    tmp.f = *variable->value;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u)); //   次要变量值
    resp->data_p += sizeof(float32_u);

    variable = get_device_variable(DEVICE_VARIABLE_CODE_248);
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }
    *resp->data_p++ = variable->units_code; //  第三变量单元代码
    tmp.f = *variable->value;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u)); //   第三变量值
    resp->data_p += sizeof(float32_u);

    variable = get_device_variable(DEVICE_VARIABLE_CODE_249);
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }
    *resp->data_p++ = variable->units_code; //  第四变量单元代码
    tmp.f = *variable->value;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u)); //   第四变量值
    resp->data_p += sizeof(float32_u);
    return TRUE;
}

/**
 * @brief读取模拟通道V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_62_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    float32_u tmp;
    if (req->data_length == 0)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    analog_channel_t *analog_channel = NULL;
    uint8_t *code = (uint8_t *)&req->data.command_62;
    for (uint8_t i = 0; i < req->data_length; i++)
    {
        analog_channel = get_analog_channel((analog_channel_number_codes_e)(*(code + i)));
        if (analog_channel == NULL)
        {
            analog_channel = get_analog_channel(ANALOG_CHANNEL_NUMBER_CODES_0);
        }
        *resp->data_p++ = analog_channel->code;       // 模拟通道代码
        *resp->data_p++ = analog_channel->units_code; // 模拟通道单元代码

        tmp.f = analog_channel->level.f;
        tmp.c = B2S_UINT32(tmp.c);
        osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u)); // 主要可变模拟电平
        resp->data_p += sizeof(float32_u);
    }

    return TRUE;
}
/**
 * @brief读取模拟通道信息V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_63_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (req->data_length == 0)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    analog_channel_t *analog_channel = NULL;
    float32_u tmp;
    analog_channel = get_analog_channel((analog_channel_number_codes_e)req->data.command_63.analog_channel_number_code);
    if (analog_channel == NULL)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_2;
        return TRUE;
    }
    *resp->data_p++ = analog_channel->code;                                              // 模拟通道代码
    *resp->data_p++ = analog_channel->attribute.alarm_selection_code;                    // 模拟通道报警选择代码
    *resp->data_p++ = analog_channel->attribute.transfer_function_code;                  // 模拟通道单元代码
    *resp->data_p++ = analog_channel->attribute.upper_and_lower_range_values_units_code; // 模拟通道上下限值单位代码

    tmp.f = analog_channel->attribute.upper_range_value; // 模拟通道上限值
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);

    tmp.f = analog_channel->attribute.lower_range_value; // 模拟通道下限值
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);

    tmp.f = analog_channel->attribute.damping_value; // 模拟通道阻尼值
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);

    if (hart_get_current_protocol_version() == HART_PROTOCOL_VERSION_7)
    {
        *resp->data_p++ = analog_channel->attribute.analog_channel_flags; // 模拟通道标志
    }
    return TRUE;
}
/**
 * @brief写入模拟通道附加阻尼值V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_64_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (req->data_length < sizeof(hart_command_64_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    analog_channel_t *analog_channel = NULL;
    float32_u tmp;
    analog_channel = get_analog_channel((analog_channel_number_codes_e)req->data.command_64.analog_channel_number_code);
    if (analog_channel == NULL)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_2;
        return TRUE;
    }
    tmp.f = req->data.command_64.damping_value;
    tmp.c = B2S_UINT32(tmp.c);
    analog_channel->attribute.damping_value = tmp.f;
    configuration_count_update();
    // 回复数据
    *resp->data_p++ = analog_channel->code; // 模拟通道代码
    tmp.f = analog_channel->attribute.damping_value;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u)); // 模拟通道阻尼值
    resp->data_p += sizeof(float32_u);
    return TRUE;
}
/**
 * @brief写入模拟通道范围值V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_65_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (req->data_length < sizeof(hart_command_65_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    analog_channel_t *analog_channel = NULL;
    float32_u tmp;
    analog_channel = get_analog_channel((analog_channel_number_codes_e)req->data.command_65.analog_channel_number_code);
    if (analog_channel == NULL)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_2;
        return TRUE;
    }
    analog_channel->attribute.upper_and_lower_range_values_units_code = req->data.command_65.upper_and_lower_range_values_units_code; // 模拟通道上下限值单位代码

    tmp.f = req->data.command_65.upper_range_value;
    tmp.c = B2S_UINT32(tmp.c);
    analog_channel->attribute.upper_range_value = tmp.f; // 模拟通道上限值

    tmp.f = req->data.command_65.lower_range_value;
    tmp.c = B2S_UINT32(tmp.c);
    analog_channel->attribute.lower_range_value = tmp.f; //  模拟通道下限值
    configuration_count_update();
    // 回复数据
    *resp->data_p++ = analog_channel->code; // 模拟通道代码
    *resp->data_p++ = analog_channel->attribute.upper_and_lower_range_values_units_code;

    tmp.f = analog_channel->attribute.upper_range_value;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u)); // 模拟通道上限值
    resp->data_p += sizeof(float32_u);

    tmp.f = analog_channel->attribute.lower_range_value;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp, sizeof(float32_u)); //  模拟通道下限值
    resp->data_p += sizeof(float32_u);
    return TRUE;
}
/**
 * @brief进入/退出固定模拟通道模式V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_66_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (req->data_length < sizeof(hart_command_66_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    float32_u tmp;
    analog_channel_t *analog_channel = NULL;
    analog_channel = get_analog_channel((analog_channel_number_codes_e)req->data.command_66.analog_channel_number_code);
    if (analog_channel == NULL)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_2;
        return TRUE;
    }
    analog_channel->units_code = req->data.command_66.units_code; // 模拟通道单元代码
    /**
     *  A level containing "0x7F. 0xA0. 0x00. 0x00'with any Units Code exits the Fixed Analog Channel Mode
     */

    osel_memcpy((uint8_t *)&tmp.f, (uint8_t *)&req->data.command_66.fixed_analog_channel_level, sizeof(int32_t)); // 这里不能直接赋值，因为0x7F. 0xA0. 0x00. 0x00会丢字节
    if (tmp.c == HART_INVALID_VALUE)
    {
        tmp.c = B2S_UINT32(tmp.c);
        osel_memcpy((uint8_t *)&analog_channel->fixed_analog_channel_level.c, (uint8_t *)&tmp.c, sizeof(int32_t));
        LOG_PRINT("%08x", analog_channel->fixed_analog_channel_level.c);
    }
    else
    {
        tmp.c = B2S_UINT32(tmp.c);
        analog_channel->fixed_analog_channel_level.f = tmp.f; // 模拟通道电平
        LOG_PRINT("%f", analog_channel->fixed_analog_channel_level.f);
    }

    configuration_count_update();
    // 回复数据
    *resp->data_p++ = analog_channel->code; // 模拟通道代码
    *resp->data_p++ = analog_channel->units_code;
    tmp.c = B2S_UINT32(analog_channel->fixed_analog_channel_level.c);
    if (tmp.c == HART_INVALID_VALUE)
    {
        osel_memcpy((uint8_t *)&tmp.c, (uint8_t *)&analog_channel->fixed_analog_channel_level.c, sizeof(int32_t));
    }
    else
    {
        tmp.c = B2S_UINT32(analog_channel->fixed_analog_channel_level.c);
    }

    osel_memcpy(resp->data_p, (uint8_t *)&tmp.c, sizeof(int32_t)); // 模拟通道电平
    resp->data_p += sizeof(int32_t);

    return TRUE;
}
/**
 * @brief调整模拟通道零V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_67_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (req->data_length < sizeof(hart_command_67_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    float32_u tmp;
    analog_channel_t *analog_channel = NULL;
    analog_channel = get_analog_channel((analog_channel_number_codes_e)req->data.command_67.analog_channel_number_code);
    if (analog_channel == NULL)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_2;
        return TRUE;
    }
    tmp.c = B2S_UINT32(analog_channel->fixed_analog_channel_level.c);
    if (tmp.c != HART_INVALID_VALUE)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_9;
        return TRUE;
    }

    analog_channel->units_code = req->data.command_67.units_code; // 模拟通道单元代码

    tmp.f = req->data.command_67.actual_analog_channel_level;
    tmp.c = B2S_UINT32(tmp.c);
    analog_channel->actual_analog_channel_level.f = tmp.f; // 模拟通道电平

    configuration_count_update();

    // 回复数据
    *resp->data_p++ = analog_channel->code; // 模拟通道代码
    *resp->data_p++ = analog_channel->units_code;
    tmp.f = analog_channel->actual_analog_channel_level.f;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp.c, sizeof(int32_t)); // 模拟通道电平
    resp->data_p += sizeof(int32_t);
    return TRUE;
}
/**
 * @brief微调模拟通道增益V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_68_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (req->data_length < sizeof(hart_command_68_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    float32_u tmp;
    analog_channel_t *analog_channel = NULL;
    analog_channel = get_analog_channel((analog_channel_number_codes_e)req->data.command_68.analog_channel_number_code);
    if (analog_channel == NULL)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_2;
        return TRUE;
    }
    tmp.c = B2S_UINT32(analog_channel->fixed_analog_channel_level.c);
    if (tmp.c != HART_INVALID_VALUE)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_9;
        return TRUE;
    }

    analog_channel->units_code = req->data.command_68.units_code; // 模拟通道单元代码

    tmp.f = req->data.command_68.externally_measured_analog_channel_level;
    tmp.c = B2S_UINT32(tmp.c);
    analog_channel->externally_measured_analog_channel_level.f = tmp.f; // 模拟通道电平

    configuration_count_update();

    // 回复数据
    *resp->data_p++ = analog_channel->code; // 模拟通道代码
    *resp->data_p++ = analog_channel->units_code;
    tmp.f = analog_channel->externally_measured_analog_channel_level.f;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp.c, sizeof(int32_t)); // 模拟通道电平
    resp->data_p += sizeof(int32_t);
    return TRUE;
}
/**
 * @brief写入模拟通道传递函数V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_69_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (req->data_length < sizeof(hart_command_69_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    analog_channel_t *analog_channel = NULL;
    analog_channel = get_analog_channel((analog_channel_number_codes_e)req->data.command_69.analog_channel_number_code);
    if (analog_channel == NULL)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_2;
        return TRUE;
    }
    analog_channel->attribute.transfer_function_code = req->data.command_69.transfer_function_code;
    configuration_count_update();
    // 回复数据
    *resp->data_p++ = analog_channel->code; // 模拟通道代码
    *resp->data_p++ = analog_channel->attribute.transfer_function_code;
    return TRUE;
}
/**
 * @brief读取模拟通道端点值V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_70_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (req->data_length < sizeof(hart_command_70_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    float32_u tmp;
    analog_channel_t *analog_channel = NULL;
    analog_channel = get_analog_channel((analog_channel_number_codes_e)req->data.command_70.analog_channel_number_code);
    if (analog_channel == NULL)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_2;
        return TRUE;
    }
    // 回复数据
    *resp->data_p++ = analog_channel->code;                                              // 模拟通道代码
    *resp->data_p++ = analog_channel->attribute.upper_and_lower_range_values_units_code; // 模拟通道上下限值单位代码

    tmp.f = analog_channel->externally_measured_analog_channel_level.f;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp.c, sizeof(int32_t)); // 模拟通道上端点值
    resp->data_p += sizeof(int32_t);

    tmp.f = analog_channel->actual_analog_channel_level.f;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp.c, sizeof(int32_t)); // 模拟通道下端点值
    resp->data_p += sizeof(int32_t);

    if (hart_get_current_protocol_version() == HART_PROTOCOL_VERSION_7)
    {
        tmp.f = analog_channel->attribute.upper_range_value; // 模拟通道上限值
        tmp.c = B2S_UINT32(tmp.c);
        osel_memcpy(resp->data_p, (uint8_t *)&tmp.c, sizeof(int32_t));
        resp->data_p += sizeof(int32_t);

        tmp.f = analog_channel->attribute.lower_range_value; // 模拟通道下限值
        tmp.c = B2S_UINT32(tmp.c);
        osel_memcpy(resp->data_p, (uint8_t *)&tmp.c, sizeof(int32_t));
        resp->data_p += sizeof(int32_t);
    }
    return TRUE;
}

/**
 * @brief 呼叫
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_72_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    uint8_t squawk_control_code = 0;
    if (req->data_length < sizeof(hart_command_72_t))
    {
        squawk_control_code = SQUAWK_CONTROL_CODE_2;
    }
    else
    {
        squawk_control_code = req->data.command_72.squawk_control_code;
    }

    if (squawk_control_code == SQUAWK_CONTROL_CODE_0)
    {
        squawk_control(FALSE, 0);
    }
    else
    {
        if (squawk_control_code == SQUAWK_CONTROL_CODE_2)
        {
            squawk_control(TRUE, HART_SQUAWK_CONTROL_ONCE_TIME);
        }
        else if (squawk_control_code == SQUAWK_CONTROL_CODE_1)
        {
            squawk_control(TRUE, 0);
        }
        else
        {
            resp->code = RESPONSE_COMMUNICATION_CODE_9;
            return TRUE;
        }
    }
    // 回复数据
    *resp->data_p++ = squawk_control_code;
    return TRUE;
}

/**
 * @brief 查找设备
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_73_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (TRUE == armed())
    {
        command_0_req(resp);
    }
    else
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_38;
        return TRUE;
    }

    return TRUE;
}

/**
 * @brief 读取I/O系统功能
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_74_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    resp->code = RESPONSE_COMMUNICATION_CODE_16;
    return TRUE;
}

/**
 * @brief 轮询子设备
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_75_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    resp->code = RESPONSE_COMMUNICATION_CODE_16;
    return TRUE;
}

/**
 * @brief 读锁定设备状态
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_76_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    *resp->data_p++ = hart_device_attribute.flash_variable.lock_code;
    return TRUE;
}


/**
 * @brief 读取设备可变微调点
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_80_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    hart_device_variable_t *hart_device_variable_p = NULL;
    float32_u tmp;
    if (req->data_length < sizeof(hart_command_80_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    hart_device_variable_p = get_device_variable(req->data.command_80.device_ariable);
    if (hart_device_variable_p->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_2;
        return TRUE;
    }
    // 回复数据
    *resp->data_p++ = hart_device_variable_p->code;
    *resp->data_p++ = hart_device_variable_p->trim_point.units_code;

    tmp.f = hart_device_variable_p->trim_point.lower;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp.c, sizeof(int32_t));
    resp->data_p += sizeof(int32_t);

    tmp.f = hart_device_variable_p->trim_point.upper;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp.c, sizeof(int32_t));
    resp->data_p += sizeof(int32_t);
    return TRUE;
}

/**
 * @brief 读取设备变量调整指南
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_81_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    float32_u tmp;
    hart_device_variable_t *variable = NULL;
    variable = get_device_variable(req->data.command_81.device_ariable);
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }

    // 回复数据
    *resp->data_p++ = variable->code;
    *resp->data_p++ = variable->trim_point.trim_points;
    *resp->data_p++ = variable->trim_point.units_code;

    tmp.f = variable->trim_point.mini_lower;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp.c, sizeof(int32_t));
    resp->data_p += sizeof(int32_t);

    tmp.f = variable->trim_point.max_lower;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp.c, sizeof(int32_t));
    resp->data_p += sizeof(int32_t);

    tmp.f = variable->trim_point.mini_upper;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp.c, sizeof(int32_t));
    resp->data_p += sizeof(int32_t);

    tmp.f = variable->trim_point.max_upper;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp.c, sizeof(int32_t));
    resp->data_p += sizeof(int32_t);

    tmp.f = variable->trim_point.mini_differential;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp.c, sizeof(int32_t));
    resp->data_p += sizeof(int32_t);
    return TRUE;
}

/**
 * @brief 写入设备可变微调点
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_82_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    float32_u tmp;
    hart_device_variable_t *variable = NULL;
    if (req->data_length < sizeof(hart_command_82_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    variable = get_device_variable(req->data.command_82.device_ariable);
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }
    variable->trim_point.trim_points = req->data.command_82.trim_points;
    variable->trim_point.units_code = req->data.command_82.units_code;
    tmp.f = req->data.command_82.value;
    tmp.c = B2S_UINT32(tmp.c);
    variable->trim_point.value = tmp.f;

    // 回复数据
    *resp->data_p++ = variable->code;
    *resp->data_p++ = variable->trim_point.trim_points;
    *resp->data_p++ = variable->trim_point.units_code;
    tmp.f = variable->trim_point.value;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp.c, sizeof(int32_t));
    resp->data_p += sizeof(int32_t);
    return TRUE;
}

/**
 * @brief 重置设备变量调整
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_83_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    hart_device_variable_t *variable = NULL;
    trim_point_t *ptr;
    if (req->data_length < sizeof(hart_command_83_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    variable = get_device_variable(req->data.command_83.device_ariable);
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }
    ptr = &variable->trim_point;
    osel_memset((uint8_t *)ptr, 0, sizeof(trim_point_t));

    // 回复数据
    *resp->data_p++ = variable->code;
    return TRUE;
}

/**
 * @brief 读取子设备标识摘要
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_84_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    resp->code = RESPONSE_COMMUNICATION_CODE_16;
    return TRUE;
}

/**
 * @brief 读取I/O通道统计信息
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_85_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    resp->code = RESPONSE_COMMUNICATION_CODE_16;
    return TRUE;
}

/**
 * @brief 读取子设备统计信息
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_86_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    resp->code = RESPONSE_COMMUNICATION_CODE_16;
    return TRUE;
}

/**
 * @brief 写入I/O系统主模式
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_87_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    resp->code = RESPONSE_COMMUNICATION_CODE_16;
    return TRUE;
}

/**
 * @brief 写入I/O系统重试计数
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_88_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    resp->code = RESPONSE_COMMUNICATION_CODE_16;
    return TRUE;
}

/**
 * @brief 读取趋势配置
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_91_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    uint32_t time = 0;
    if (req->data_length < sizeof(hart_command_91_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    if (req->data.command_91.trend_number > TREND_CONFIGURATIONS_LEN)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_11;
        return TRUE;
    }

    trend_configuration_t *cnf = &hart_device_attribute.flash_variable.trend_configurations[req->data.command_91.trend_number];
    // 回复数据
    *resp->data_p++ = req->data.command_91.trend_number;
    *resp->data_p++ = TREND_CONFIGURATIONS_LEN;
    *resp->data_p++ = cnf->trend_code;
    *resp->data_p++ = cnf->device_variable_code;
    time = cnf->trend_sample_interval;
    time = B2S_UINT32(time);
    osel_memcpy(resp->data_p, (uint8_t *)&time, sizeof(uint32_t));
    resp->data_p += sizeof(uint32_t);
    return TRUE;
}

/**
 * @brief 写入趋势配置
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_92_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    uint32_t time = 0;
    if (req->data_length < sizeof(hart_command_92_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    if (req->data.command_92.trend_code >= TREND_CONTROL_CODE_MAX)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_2;
        return TRUE;
    }
    if (req->data.command_92.trend_number > TREND_CONFIGURATIONS_LEN)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_11;
        return TRUE;
    }
    time = S2B_UINT32(req->data.command_92.trend_sample_interval);
    if (time > 2 * 3600 * 1000)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_3;
        return TRUE;
    }

    trend_configuration_t *cnf = &hart_device_attribute.flash_variable.trend_configurations[req->data.command_92.trend_number];
    cnf->trend_code = req->data.command_92.trend_code;
    cnf->device_variable_code = req->data.command_92.device_variable_code;
    cnf->trend_sample_interval = time;

    configuration_count_update();

    // 回复数据
    *resp->data_p++ = req->data.command_92.trend_number;
    *resp->data_p++ = cnf->trend_code;
    *resp->data_p++ = cnf->device_variable_code;
    time = cnf->trend_sample_interval;
    time = B2S_UINT32(time);
    osel_memcpy(resp->data_p, (uint8_t *)&time, sizeof(uint32_t));
    resp->data_p += sizeof(uint32_t);
    return TRUE;
}

/**
 * @brief 读取趋势
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_93_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    uint32_t time = 0;
    trend_value_t *value = NULL;
    float32_u tmp;
    if (req->data_length < sizeof(hart_command_93_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    if (req->data.command_93.trend_number > TREND_CONFIGURATIONS_LEN)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_11;
        return TRUE;
    }
    trend_configuration_t *cnf = &hart_device_attribute.flash_variable.trend_configurations[req->data.command_93.trend_number];
    // 回复数据
    // 趋势编号
    *resp->data_p++ = req->data.command_93.trend_number;
    // 设备变量代码
    *resp->data_p++ = cnf->device_variable_code;
    // 设备变量分类
    *resp->data_p++ = cnf->device_variable_classification;
    // 设备变量单位代码
    *resp->data_p++ = cnf->device_variable_unit_code;
    // 趋势值的日期戳
    osel_memcpy(resp->data_p, cnf->trend_value_date, HART_DATE_LEN);
    resp->data_p += HART_DATE_LEN;
    // 趋势值的时间戳
    time = cnf->trend_value_time;
    time = S2B_UINT32(time);
    osel_memcpy(resp->data_p, (uint8_t *)&time, sizeof(uint32_t));
    resp->data_p += sizeof(uint32_t);
    // 采样间隔
    time = cnf->trend_sample_interval;
    time = S2B_UINT32(time);
    osel_memcpy(resp->data_p, (uint8_t *)&time, sizeof(uint32_t));
    resp->data_p += sizeof(uint32_t);

    // 趋势值
    if (cnf->trend_code == TREND_CONTROL_CODE_0)
    {
        // 当趋势未启用时，设备应返回最后收集的数据与相应的日期和时间,响应代码应设置为趋势不活跃
        resp->code = RESPONSE_COMMUNICATION_CODE_8;
    }
    else
    {
        for (uint8_t i = 0; i < TREND_VALUES_LEN; i++)
        {
            value = &cnf->trend_values[i];
            tmp.f = value->value;
            tmp.c = S2B_UINT32(tmp.c);
            osel_memcpy(resp->data_p, (uint8_t *)&tmp.c, sizeof(int32_t));
            resp->data_p += sizeof(int32_t);
            *resp->data_p++ = value->status.data;
        }
    }

    return TRUE;
}

/**
 * @brief 读取I/O系统客户端通信统计信息
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_94_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    resp->code = RESPONSE_COMMUNICATION_CODE_16;
    return TRUE;
}

/**
 * @brief 读取设备通信统计信息
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_95_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    *resp->data_p++ = HI_UINT16(hart_device_attribute.message_count.stx);
    *resp->data_p++ = LO_UINT16(hart_device_attribute.message_count.stx);
    *resp->data_p++ = HI_UINT16(hart_device_attribute.message_count.ack);
    *resp->data_p++ = LO_UINT16(hart_device_attribute.message_count.ack);
    *resp->data_p++ = HI_UINT16(hart_device_attribute.message_count.back);
    *resp->data_p++ = LO_UINT16(hart_device_attribute.message_count.back);
    return TRUE;
}

/**
 * @brief 读取同步操作
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_96_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    uint32_t time = 0;
    if (req->data_length < sizeof(hart_command_96_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    if (req->data.command_96.action_number > SYNCHRONIZATION_OPERATION_LEN)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_11;
        return TRUE;
    }
    synchronization_operation_t *tmp = &hart_device_attribute.flash_variable.synchronization_operations[req->data.command_96.action_number];
    // 回复数据
    *resp->data_p++ = req->data.command_96.action_number; // 同步操作编号
    *resp->data_p++ = SYNCHRONIZATION_OPERATION_LEN;      // 同步操作总数

    *resp->data_p++ = tmp->action_control_code; // 同步操作控制代码
    if (tmp->action_control_code == 0)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_2;
        // 未使用的
        *resp->data_p++ = DEVICE_VARIABLE_CODE_251; // 同步操作设备变量代码
        *resp->data_p++ = 0xff;                     // 同步操作命令编号
        *resp->data_p++ = 0xff;
    }
    else
    {
        *resp->data_p++ = tmp->device_variable_code;      // 同步操作设备变量代码
        *resp->data_p++ = HI_UINT16(tmp->command_number); // 同步操作命令编号
        *resp->data_p++ = LO_UINT16(tmp->command_number);
    }

    osel_memcpy(resp->data_p, tmp->trigger_date, HART_DATE_LEN); // 同步操作日期
    resp->data_p += HART_DATE_LEN;
    time = tmp->trigger_time; // 同步操作时间
    time = S2B_UINT32(time);
    osel_memcpy(resp->data_p, (uint8_t *)&time, sizeof(uint32_t));
    resp->data_p += sizeof(uint32_t);
    return TRUE;
}

/**
 * @brief 配置同步操作
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_97_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    uint32_t time = 0;
    /**
     *  0	Success	No Command-Specific Errors
        1   Undefined
        2	Error	Invalid Selection
        3-4	Undefined
        5	Error	Too Few Data Bytes Received
        6	Error	Device-Specific Command Error
        7	Error	In Write Protect Mode
        8	Warning	Sampling Time Adjusted
        9	Error	Bad Trigger Action
        10	Error	Invalid Date
        11	Error	Invalid Time
        12	Error	Invalid Device Variable
        13	Error	Command Number Not Supported
        14-15		Undefined
    */
    if (req->data_length < sizeof(hart_command_97_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    if (req->data.command_97.action_number > SYNCHRONIZATION_OPERATION_LEN)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_9;
        return TRUE;
    }
    synchronization_operation_t *tmp = &hart_device_attribute.flash_variable.synchronization_operations[req->data.command_97.action_number];
    tmp->action_control_code = req->data.command_97.action_control_code; // 同步操作控制代码

    // 设备变量代码。如果动作执行命令，设备变量代码必须设置为251。“NONE”。
    if (tmp->action_control_code == SYNCHRONIZATION_OPERATION_CONTROL_CODE_1)
    {
        tmp->device_variable_code = req->data.command_97.device_variable_code; // 同步操作设备变量代码
    }
    else
    {
        tmp->device_variable_code = DEVICE_VARIABLE_CODE_251;
    }

    // 命令编号。如果操作是对设备变量进行采样，则命令编号必须设置为0xFFFF。
    if (tmp->action_control_code == SYNCHRONIZATION_OPERATION_CONTROL_CODE_1)
    {
        tmp->command_number = 0xffff;
    }
    else
    {

        tmp->command_number = S2B_UINT16(req->data.command_97.command_number); // 同步操作命令编号
    }

    osel_memcpy(tmp->trigger_date, req->data.command_97.trigger_date, HART_DATE_LEN);
    time = S2B_UINT32(req->data.command_97.trigger_time); // 同步操作时间
    tmp->trigger_time = time;

    configuration_count_update();

    // 回复数据
    *resp->data_p++ = req->data.command_97.action_number; // 同步操作编号
    *resp->data_p++ = tmp->action_control_code;           // 同步操作控制代码
    *resp->data_p++ = tmp->device_variable_code;          // 同步操作设备变量代码
    *resp->data_p++ = HI_UINT16(tmp->command_number);     // 同步操作命令编号
    *resp->data_p++ = LO_UINT16(tmp->command_number);
    osel_memcpy(resp->data_p, tmp->trigger_date, HART_DATE_LEN); // 同步操作日期
    resp->data_p += HART_DATE_LEN;
    time = tmp->trigger_time; // 同步操作时间
    time = S2B_UINT32(time);
    osel_memcpy(resp->data_p, (uint8_t *)&time, sizeof(uint32_t));
    resp->data_p += sizeof(uint32_t);
    return TRUE;
}

/**
 * @brief 读取命令操作
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_98_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (req->data_length < sizeof(hart_command_98_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    if (req->data.command_98.action_number > SYNCHRONIZATION_OPERATION_LEN)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_11;
        return TRUE;
    }
    synchronization_operation_t *tmp = &hart_device_attribute.flash_variable.synchronization_operations[req->data.command_98.action_number];
    // 回复数据
    *resp->data_p++ = req->data.command_98.action_number; // 同步操作编号
    *resp->data_p++ = HI_UINT16(tmp->command_number);     // 同步操作命令编号
    *resp->data_p++ = LO_UINT16(tmp->command_number);
    *resp->data_p++ = tmp->command_data_length;                             // 字节计数
    osel_memcpy(resp->data_p, tmp->command_data, tmp->command_data_length); // 命令数据
    resp->data_p += tmp->command_data_length;
    return TRUE;
}

/**
 * @brief 配置命令操作
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_99_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (req->data_length < (4 + req->data.command_99.command_data_length))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    if (req->data.command_99.action_number > SYNCHRONIZATION_OPERATION_LEN)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_11;
        return TRUE;
    }
    if (req->data.command_99.command_data_length > SYNCHRONIZATION_OPERATION_COMMAND_DATA_LEN)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_10;
        return TRUE;
    }

    synchronization_operation_t *tmp = &hart_device_attribute.flash_variable.synchronization_operations[req->data.command_99.action_number];
    tmp->command_number = req->data.command_99.command_number;
    tmp->command_data_length = req->data.command_99.command_data_length;
    osel_memcpy(tmp->command_data, req->data.command_99.command_data, tmp->command_data_length);
    configuration_count_update();

    // 回复数据
    *resp->data_p++ = req->data.command_99.action_number; // 同步操作编号
    *resp->data_p++ = HI_UINT16(tmp->command_number);     // 同步操作命令编号
    *resp->data_p++ = LO_UINT16(tmp->command_number);
    *resp->data_p++ = tmp->command_data_length;                             // 字节计数
    osel_memcpy(resp->data_p, tmp->command_data, tmp->command_data_length); // 命令数据
    resp->data_p += tmp->command_data_length;
    return TRUE;
}


/**
 * @brief 写入主变量报警码
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_100_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (req->data_length < sizeof(hart_command_100_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    hart_device_variable_t *variable = NULL;
    variable = get_device_variable(DEVICE_VARIABLE_CODE_246);
    if (variable->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_6;
        return TRUE;
    }
    variable->alarm_code = req->data.command_100.pv_alarm_selection_code;
    configuration_count_update();
    // 回复数据
    *resp->data_p++ = variable->alarm_code;
    return TRUE;
}


/**
 * @brief 写入突发周期
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_103_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    uint32_t time1, time2;
    if (req->data_length < sizeof(hart_command_103_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    if (req->data.command_103.burst_message > BURST_MESSAGE_LEN)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_9;
        return TRUE;
    }
    burst_message_t *tmp = &hart_device_attribute.flash_variable.burst_messages[req->data.command_103.burst_message];

    // 校验更新时间
    time1 = B2S_UINT32(req->data.command_103.update_period_time);
    if (time1 > BURST_MESSAGE_UPDATE_TIME_MAX * 1000)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_8;
        return TRUE;
    }
    time2 = B2S_UINT32(req->data.command_103.max_update_period_time);
    if (time2 > BURST_MESSAGE_UPDATE_TIME_MAX * 1000)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_8;
        return TRUE;
    }

    tmp->update_period_time = time1;
    tmp->max_update_period_time = time2;

    configuration_count_update();

    // 回复数据
    *resp->data_p++ = req->data.command_103.burst_message; // 突发消息编号
    time1 = S2B_UINT32(tmp->update_period_time);
    osel_memcpy(resp->data_p, (uint8_t *)&time1, sizeof(uint32_t)); // 更新周期时间
    resp->data_p += sizeof(uint32_t);
    time2 = S2B_UINT32(tmp->max_update_period_time);
    osel_memcpy(resp->data_p, (uint8_t *)&time2, sizeof(uint32_t)); // 最大更新周期时间
    resp->data_p += sizeof(uint32_t);

    return TRUE;
}
/**
 * @brief 写入突发触发器
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_104_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    float32_u f;
    if (req->data_length < sizeof(hart_command_104_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    if (req->data.command_104.burst_message > BURST_MESSAGE_LEN)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_9;
        return TRUE;
    }
    f.f = req->data.command_104.trigger_level;
    f.c = B2S_UINT32(f.c);
    burst_message_t *tmp = &hart_device_attribute.flash_variable.burst_messages[req->data.command_104.burst_message];
    tmp->burst_message_trigger_code = req->data.command_104.burst_message_trigger_code;                                             //  突发触发器代码
    tmp->device_variable_vlassification_for_trigger_level = req->data.command_104.device_variable_vlassification_for_trigger_level; //  触发器级别的设备变量分类
    tmp->units_code = req->data.command_104.units_code;                                                                             //  突发触发器单位代码
    tmp->trigger_level = f.f;                                                                                                       //  触发电平

    configuration_count_update();

    // 回复数据
    f.f = tmp->trigger_level;
    f.c = S2B_UINT32(f.c);
    *resp->data_p++ = req->data.command_104.burst_message;                   // 突发消息编号
    *resp->data_p++ = tmp->burst_message_trigger_code;                       // 突发触发器代码
    *resp->data_p++ = tmp->device_variable_vlassification_for_trigger_level; // 触发器级别的设备变量分类
    *resp->data_p++ = tmp->units_code;                                       // 突发触发器单位代码
    osel_memcpy(resp->data_p, (uint8_t *)&f, sizeof(float32_u));             // 触发电平
    resp->data_p += sizeof(float32_u);
    return TRUE;
}
/**
 * @brief 读取突发模式配置
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_105_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    uint32_t time;
    float32_u f;
    hart_device_variable_t *solt;
    if (req->data.command_105.burst_message > BURST_MESSAGE_LEN)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_9;
        return TRUE;
    }
    burst_message_t *tmp = &hart_device_attribute.flash_variable.burst_messages[req->data.command_105.burst_message];

    *resp->data_p++ = tmp->burst_mode_control_code;       // 突发模式控制代码
    *resp->data_p++ = tmp->command_number_expansion_flag; // 命令编号扩展标志
    for (uint8_t i = 0; i < HART_DEVICE_VARIABLE_LEN; i++)
    {
        solt = &hart_device_attribute.flash_variable.device_variable[i];
        *resp->data_p++ = solt->code; // 设备变量代码
    }
    *resp->data_p++ = req->data.command_105.burst_message;     //  突发消息编号
    *resp->data_p++ = BURST_MESSAGE_LEN;                       //  设备支持的最大突发消息数
    *resp->data_p++ = HI_UINT16(tmp->extended_command_number); //  扩展命令编号
    *resp->data_p++ = LO_UINT16(tmp->extended_command_number); //  扩展命令编号
    time = S2B_UINT32(tmp->update_period_time);                //  更新周期时间
    osel_memcpy(resp->data_p, (uint8_t *)&time, sizeof(uint32_t));
    resp->data_p += sizeof(uint32_t);
    time = S2B_UINT32(tmp->max_update_period_time); //  最大更新周期时间
    osel_memcpy(resp->data_p, (uint8_t *)&time, sizeof(uint32_t));
    resp->data_p += sizeof(uint32_t);
    *resp->data_p++ = tmp->burst_message_trigger_code;                       //  突发触发器代码
    *resp->data_p++ = tmp->device_variable_vlassification_for_trigger_level; //  触发器级别的设备变量分类
    *resp->data_p++ = tmp->units_code;                                       //  突发触发器单位代码
    f.f = tmp->trigger_level;                                                //  触发电平
    f.c = S2B_UINT32(f.c);
    osel_memcpy(resp->data_p, (uint8_t *)&f, sizeof(float32_u));
    resp->data_p += sizeof(float32_u);
    return TRUE;
}

/**
 * @brief 写入突发设备变量
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_107_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    hart_device_variable_t *solt;
    if (req->data_length < sizeof(hart_command_107_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }

    if (*hart_device_attribute.hart_protocol_version == HART_PROTOCOL_VERSION_7)
    {
        if (req->data_length != 9)
        {
            resp->code = RESPONSE_COMMUNICATION_CODE_16;
            return TRUE;
        }
    }
    else if (*hart_device_attribute.hart_protocol_version == HART_PROTOCOL_VERSION_5)
    {
        if (req->data_length != 5)
        {
            resp->code = RESPONSE_COMMUNICATION_CODE_16;
            return TRUE;
        }
    }

    // 分配给插槽设备变量代码

    for (uint8_t i = 0; i < HART_DEVICE_VARIABLE_LEN; i++)
    {
        solt = &hart_device_attribute.flash_variable.device_variable[i];
        solt->code = req->data.command_107.solt_device_variable_codes[i];
    }

    // 回复数据
    for (uint8_t i = 0; i < HART_DEVICE_VARIABLE_LEN; i++)
    {
        solt = &hart_device_attribute.flash_variable.device_variable[i];
        *resp->data_p++ = solt->code;
    }
    *resp->data_p++ = req->data.command_107.burst_message; // 突发消息编号
    return TRUE;
}


/**
 * @brief注册事件管理器
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_514_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (req->data_length < sizeof(hart_command_514_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    if (req->data.command_514.event_manager_registration_control_code == EVENT_MANAGER_REGISTRATION_CONTROL_CODE_0 &&
        hart_device_attribute.flash_variable.event_manager_registration_control_code == EVENT_MANAGER_REGISTRATION_CONTROL_CODE_0)
    {
        // Access Restricted (e.g., an Event Manager is already registered)
        resp->code = RESPONSE_COMMUNICATION_CODE_16;
        return TRUE;
    }
    hart_device_attribute.flash_variable.event_manager_registration_control_code = req->data.command_514.event_manager_registration_control_code;
    configuration_count_update();
    // 回复数据
    *resp->data_p++ = hart_device_attribute.flash_variable.event_manager_registration_control_code;

    return TRUE;
}
/**
 * @brief读取事件管理器注册状态
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_515_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    // 回复数据
    *resp->data_p++ = hart_device_attribute.flash_variable.event_manager_registration_control_code;
    return TRUE;
}


/**
 * @brief读取进程单元标签
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_520_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief写入进程单元标记
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_521_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief写入进程单元标记
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_522_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief写入体积流分类
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_523_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief写入精简状态映射
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_524_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief重置精简状态图
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_525_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief写入状态模拟模式
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_526_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief模拟状态位
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_527_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief读取子设备分配列表信息
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_528_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief读取子设备分配
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_529_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief写入子设备分配
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_530_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief将实时列表传输到分配列表
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_531_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief读取客户端订阅摘要
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_532_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief写入客户端订阅标志
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_533_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}

/**
 * @brief写入模拟通道端点值
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_535_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief写入应用时间操作
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_536_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief读取应用时间操作
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_537_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief读取HART-IP服务器端口
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_538_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief写入HART-IP UDP端口
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_539_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief写入HART-IP TCP端口
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_540_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief写入客户端PAKE密码
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_541_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief写入客户端预共享密钥
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_542_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief读取系统日志服务器主机名和端口
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_543_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief写入系统日志端口
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_544_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief写入系统日志服务器主机名
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_545_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief写入系统日志服务器预共享密钥
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_546_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief写入系统日志服务器PAKE密码
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_547_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
#endif

/**
 * @brief EEPROM控制V5   0 刻录EEPROM 1 恢复影子内存
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_39_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    BOOL ret = FALSE;
    if (req->data_length < sizeof(hart_command_39_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }

    if (0 == req->data.command_39.control_code)
    {
        ret = hart_storage_write(HART_EEPROM_ADDRESS, (uint8_t *)&hart_device_attribute.flash_variable, sizeof(hart_storage_variable_t));
    }
    else
    {
        ret = hart_storage_read(HART_EEPROM_ADDRESS, (uint8_t *)&hart_device_attribute.flash_variable, sizeof(hart_storage_variable_t));
    }
    if (TRUE == ret)
    {
        BIT_CLR(hart_device_attribute.device_status.operational_state, DEVICE_OPERATIONAL_STATE_7 | DEVICE_OPERATIONAL_STATE_8);
    }
    else
    {
        BIT_SET(hart_device_attribute.device_status.operational_state, DEVICE_OPERATIONAL_STATE_8);
    }

    // 回复数据
    *resp->data_p++ = req->data.command_39.control_code;
    return TRUE;
}

/**
 * @brief 执行自检V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_41_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    perform_self_test(); // TODO 跳转到自检画面
    return TRUE;
}

/**
 * @brief 执行设备重置V5
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_42_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    device_reset();
    return TRUE;
}

/**
 * @brief 锁定装置
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_71_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (req->data_length < sizeof(hart_command_71_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    uint8_t lock_code = hart_device_attribute.flash_variable.lock_code;
    if (req->data.command_71.lock_code == LOCK_DEVICE_CODE_0)
    {
        if (lock_code != LOCK_DEVICE_CODE_0) // 判断当前锁定状态
        {
            if (req->master == 0)
            {
                if (lock_code != LOCK_DEVICE_CODE_3)
                {
                    // 第二主机 不能解锁
                    resp->code = RESPONSE_COMMUNICATION_CODE_10; // 不能解锁
                    return TRUE;
                }
            }
        }
        hart_device_attribute.flash_variable.lock_code = req->data.command_71.lock_code;
    }
    else
    {
        if (req->master == 0 && req->data.command_71.lock_code != LOCK_DEVICE_CODE_3)
        {
            // 第二主机 不能锁定
            resp->code = RESPONSE_COMMUNICATION_CODE_11;
            return TRUE;
        }

        hart_device_attribute.flash_variable.lock_code = req->data.command_71.lock_code;
    }

    // 更改锁定代码不会影响配置更改计数器或配置更改位
    // 回复数据
    *resp->data_p++ = hart_device_attribute.flash_variable.lock_code;

    return TRUE;
}

// /**
//  * @brief 向子设备发送命令
//  * @param {hart_command_req_t} *req
//  * @param {hart_response_t} *resp
//  * @return {*}
//  */
// static BOOL hart_slave_command_77_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     resp->code = RESPONSE_COMMUNICATION_CODE_16;
//     return TRUE;
// }

// /**
//  * @brief 读取聚合命令
//  * @param {hart_command_req_t} *req
//  * @param {hart_response_t} *resp
//  * @return {*}
//  */
// static BOOL hart_slave_command_78_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     resp->code = RESPONSE_COMMUNICATION_CODE_16;
//     return TRUE;
// }

/**
 * @brief 写入设备变量
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_79_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    hart_device_variable_t *hart_device_variable_p = NULL;
    float32_u tmp;
    if (req->data_length < sizeof(hart_command_79_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    hart_device_variable_p = get_device_variable(req->data.command_79.device_ariable);
    if (hart_device_variable_p->code == DEVICE_VARIABLE_CODE_250)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_2;
        return TRUE;
    }
    hart_device_variable_p->write_device_variable_command_code = req->data.command_79.device_ariable_command_code;
    hart_device_variable_p->units_code = req->data.command_79.device_ariable_unit_code;
    tmp.f = req->data.command_79.device_ariable_value;
    tmp.c = B2S_UINT32(tmp.c);
    *hart_device_variable_p->value = tmp.f;
    hart_device_variable_p->status.data = req->data.command_79.status;
    configuration_count_update();

    // 回复数据
    *resp->data_p++ = hart_device_variable_p->code;
    *resp->data_p++ = hart_device_variable_p->write_device_variable_command_code;
    *resp->data_p++ = hart_device_variable_p->units_code;
    tmp.f = *hart_device_variable_p->value;
    tmp.c = B2S_UINT32(tmp.c);
    osel_memcpy(resp->data_p, (uint8_t *)&tmp.c, sizeof(int32_t));
    resp->data_p += sizeof(int32_t);
    *resp->data_p++ = hart_device_variable_p->status.data;
    return TRUE;
}

/**
 * @brief 设置实时时钟
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_89_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    uint32_t time;
    uint8_t year, month, day, hour, min, sec;

    if (req->data_length < sizeof(hart_command_89_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    if (req->data.command_89.time_set_code >= TIME_SETTING_CODE_MAX)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_2;
        return TRUE;
    }

    hart_device_attribute.flash_variable.real_time_clock.time_set_code = req->data.command_89.time_set_code;
    osel_memcpy(hart_device_attribute.flash_variable.real_time_clock.date, req->data.command_89.date, HART_DATE_LEN);
    time = B2S_UINT32(req->data.command_89.time);
    hart_device_attribute.flash_variable.real_time_clock.time = time;
    hart_device_attribute.flash_variable.real_time_clock.transmission_time = req->data.command_89.transmission_time;

    configuration_count_update();

    year = hart_device_attribute.flash_variable.real_time_clock.date[2];
    covert_year_rtc(&year);
    year = dec_format_hex(year);
    month = dec_format_hex(hart_device_attribute.flash_variable.real_time_clock.date[1]);
    day = dec_format_hex(hart_device_attribute.flash_variable.real_time_clock.date[0]);

    convert_time(time, &hour, &min, &sec);
    set_real_time_clock(year, month, day, hour, min, sec);
    hart_device_attribute.flash_variable.real_time_clock.rtc_flags = REAL_TIME_CLOCK_FLAGS_1;
    // 保存到flash
    if (FALSE == falsh_write())
    {
        falsh_read();
        resp->code = RESPONSE_COMMUNICATION_CODE_8;
        return TRUE;
    }
    // LOG_PRINT("%d,%d,%d", hour, min, sec);
    // 回复数据

    *resp->data_p++ = hart_device_attribute.flash_variable.real_time_clock.time_set_code;
    osel_memcpy(resp->data_p, hart_device_attribute.flash_variable.real_time_clock.date, HART_DATE_LEN);
    resp->data_p += HART_DATE_LEN;
    time = hart_device_attribute.flash_variable.real_time_clock.time;
    time = S2B_UINT32(time);
    osel_memcpy(resp->data_p, (uint8_t *)&time, sizeof(uint32_t));
    resp->data_p += sizeof(uint32_t);

    return TRUE;
}

/**
 * @brief 读取实时时钟
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_90_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    uint8_t year, month, day, hour, min, sec;
    uint32_t time;
    get_real_time_clock(&year, &month, &day, &hour, &min, &sec);
    convert_timestrap(&time, hour, min, sec, 0);

    // 当前日期
    *resp->data_p++ = day;
    *resp->data_p++ = month;
    *resp->data_p++ = year > 0 ? (year + 100) : 0;
    // 当前时间
    time = S2B_UINT32(time);
    osel_memcpy(resp->data_p, (uint8_t *)&time, sizeof(uint32_t));
    resp->data_p += sizeof(uint32_t);

    // 上一次设置的日期
    osel_memcpy(resp->data_p, hart_device_attribute.flash_variable.real_time_clock.date, HART_DATE_LEN);
    resp->data_p += HART_DATE_LEN;
    // 上一次设置的时间
    time = hart_device_attribute.flash_variable.real_time_clock.time;
    time = S2B_UINT32(time);
    osel_memcpy(resp->data_p, (uint8_t *)&time, sizeof(uint32_t));
    resp->data_p += sizeof(uint32_t);
    // RTC标志
    *resp->data_p++ = hart_device_attribute.flash_variable.real_time_clock.rtc_flags;

    return TRUE;
}

/**
 * @brief 读取设备变量命令代码
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_534_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}

// /**
//  * @brief 读取子设备到突发消息映射
//  * @param {hart_command_req_t} *req
//  * @param {hart_response_t} *resp
//  * @return {*}
//  */
// static BOOL hart_slave_command_101_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     resp->code = RESPONSE_COMMUNICATION_CODE_16;
//     return TRUE;
// }
// /**
//  * @brief 将子设备映射到突发信息
//  * @param {hart_command_req_t} *req
//  * @param {hart_response_t} *resp
//  * @return {*}
//  */
// static BOOL hart_slave_command_102_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     resp->code = RESPONSE_COMMUNICATION_CODE_16;
//     return TRUE;
// }

// /**
//  * @brief 刷新延迟响应
//  * @param {hart_command_req_t} *req
//  * @param {hart_response_t} *resp
//  * @return {*}
//  */
// static BOOL hart_slave_command_106_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     resp->code = RESPONSE_COMMUNICATION_CODE_16;
//     return TRUE;
// }

// /**
//  * @brief 写入突发模式命令编号
//  * @param {hart_command_req_t} *req
//  * @param {hart_response_t} *resp
//  * @return {*}
//  */
// static BOOL hart_slave_command_108_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     resp->code = RESPONSE_COMMUNICATION_CODE_16;
//     return TRUE;
// }
// /**
//  * @brief 突发模式控制V5
//  * @param {hart_command_req_t} *req
//  * @param {hart_response_t} *resp
//  * @return {*}
//  */
// static BOOL hart_slave_command_109_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     resp->code = RESPONSE_COMMUNICATION_CODE_16;
//     return TRUE;
// }

// /**
//  * @brief 读取所有动态变量V5 (新设计不建议使用此命令)
//  * @param {hart_command_req_t} *req
//  * @param {hart_response_t} *resp
//  * @return {*}
//  */
// static BOOL hart_slave_command_110_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     hart_device_variable_t *dv;
//     float32_u f;

//     dv = get_device_variable(DEVICE_VARIABLE_CODE_246); // 主变量
//     *resp->data_p++ = dv->code;
//     f.f = *dv->value;
//     f.c = S2B_UINT32(f.c);
//     osel_memcpy(resp->data_p, (uint8_t *)&f, sizeof(float32_u));
//     resp->data_p += sizeof(float32_u);

//     dv = get_device_variable(DEVICE_VARIABLE_CODE_247); // 第二变量
//     *resp->data_p++ = dv->code;
//     f.f = *dv->value;
//     f.c = S2B_UINT32(f.c);
//     osel_memcpy(resp->data_p, (uint8_t *)&f, sizeof(float32_u));
//     resp->data_p += sizeof(float32_u);

//     dv = get_device_variable(DEVICE_VARIABLE_CODE_248); // 第三变量
//     *resp->data_p++ = dv->code;
//     f.f = *dv->value;
//     f.c = S2B_UINT32(f.c);
//     osel_memcpy(resp->data_p, (uint8_t *)&f, sizeof(float32_u));
//     resp->data_p += sizeof(float32_u);

//     dv = get_device_variable(DEVICE_VARIABLE_CODE_249); // 第四变量
//     *resp->data_p++ = dv->code;
//     f.f = *dv->value;
//     f.c = S2B_UINT32(f.c);
//     osel_memcpy(resp->data_p, (uint8_t *)&f, sizeof(float32_u));
//     resp->data_p += sizeof(float32_u);
//     return TRUE;
// }

// /**
//  * @brief转移服务控制
//  * @param {hart_command_req_t} *req
//  * @param {hart_response_t} *resp
//  * @return {*}
//  */
// static BOOL hart_slave_command_111_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     resp->code = RESPONSE_COMMUNICATION_CODE_16;
//     return TRUE;
// }
// /**
//  * @brief传输服务
//  * @param {hart_command_req_t} *req
//  * @param {hart_response_t} *resp
//  * @return {*}
//  */
// static BOOL hart_slave_command_112_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     resp->code = RESPONSE_COMMUNICATION_CODE_16;
//     return TRUE;
// }
// /**
//  * @brief捕获设备变量
//  * @param {hart_command_req_t} *req
//  * @param {hart_response_t} *resp
//  * @return {*}
//  */
// static BOOL hart_slave_command_113_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     resp->code = RESPONSE_COMMUNICATION_CODE_16;
//     return TRUE;
// }
// /**
//  * @brief读取捕获的设备变量
//  * @param {hart_command_req_t} *req
//  * @param {hart_response_t} *resp
//  * @return {*}
//  */
// static BOOL hart_slave_command_114_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     resp->code = RESPONSE_COMMUNICATION_CODE_16;
//     return TRUE;
// }
// /**
//  * @brief读取事件通知摘要
//  * @param {hart_command_req_t} *req
//  * @param {hart_response_t} *resp
//  * @return {*}
//  */
// static BOOL hart_slave_command_115_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     resp->code = RESPONSE_COMMUNICATION_CODE_16;
//     return TRUE;
// }
// /**
//  * @brief写入事件通知位掩码
//  * @param {hart_command_req_t} *req
//  * @param {hart_response_t} *resp
//  * @return {*}
//  */
// static BOOL hart_slave_command_116_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     resp->code = RESPONSE_COMMUNICATION_CODE_16;
//     return TRUE;
// }
// /**
//  * @brief写入事件通知时序
//  * @param {hart_command_req_t} *req
//  * @param {hart_response_t} *resp
//  * @return {*}
//  */
// static BOOL hart_slave_command_117_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     resp->code = RESPONSE_COMMUNICATION_CODE_16;
//     return TRUE;
// }
// /**
//  * @brief事件通知控制
//  * @param {hart_command_req_t} *req
//  * @param {hart_response_t} *resp
//  * @return {*}
//  */
// static BOOL hart_slave_command_118_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     resp->code = RESPONSE_COMMUNICATION_CODE_16;
//     return TRUE;
// }
// /**
//  * @brief确认事件通知
//  * @param {hart_command_req_t} *req
//  * @param {hart_response_t} *resp
//  * @return {*}
//  */
// static BOOL hart_slave_command_119_req(const hart_command_req_t *const req, hart_response_t *resp)
// {
//     resp->code = RESPONSE_COMMUNICATION_CODE_16;
//     return TRUE;
// }

/**
 * @brief 读取国家代码
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_512_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    *resp->data_p++ = HI_UINT16(hart_device_attribute.flash_variable.country_code);
    *resp->data_p++ = LO_UINT16(hart_device_attribute.flash_variable.country_code);
    *resp->data_p++ = hart_device_attribute.flash_variable.si_units_control_code;
    return TRUE;
}

/**
 * @brief 编写国家代码
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_513_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    if (req->data_length < sizeof(hart_command_513_t))
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_5;
        return TRUE;
    }
    if (req->data.command_513.si_units_control_code >= SI_UNITS_CONTROL_CODE_MAX)
    {
        resp->code = RESPONSE_COMMUNICATION_CODE_8;
        return TRUE;
    }
    hart_device_attribute.flash_variable.country_code = B2S_UINT16(req->data.command_513.country_code);
    hart_device_attribute.flash_variable.si_units_control_code = req->data.command_513.si_units_control_code;
    configuration_count_update();
    // 回复数据
    *resp->data_p++ = HI_UINT16(hart_device_attribute.flash_variable.country_code);
    *resp->data_p++ = LO_UINT16(hart_device_attribute.flash_variable.country_code);
    *resp->data_p++ = hart_device_attribute.flash_variable.si_units_control_code;
    return TRUE;
}

/**
 * @brief读取设备位置
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_516_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief写入设备位置
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_517_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief读取位置说明
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_518_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}
/**
 * @brief写入位置说明
 * @param {hart_command_req_t} *req
 * @param {hart_response_t} *resp
 * @return {*}
 */
static BOOL hart_slave_command_519_req(const hart_command_req_t *const req, hart_response_t *resp)
{
    return TRUE;
}

/**
 * @brief 初始化哈希表，用于注册从端发送给主端的命令的处理函数。
 * @return 无
 * @note 此函数通常在哈希表的初始化时调用，以设置默认的未定义命令。
 */
void hart_slave_req_init(void)
{
    for (uint16_t i = 0; i < HART_COMMAND_MAX; i++)
    {
        hart_command_ptr_arr[i] = hart_slave_command_undef_req; // 默认为未定义命令
    }

    // 通用命令 23条
    hart_command_ptr_arr[HART_COMMAND_0] = hart_slave_command_0_req;   // 读取唯一标识命令
    hart_command_ptr_arr[HART_COMMAND_1] = hart_slave_command_1_req;   // 读取主变量
    hart_command_ptr_arr[HART_COMMAND_2] = hart_slave_command_2_req;   // 读取主变量的回路电流和量程百分比
    hart_command_ptr_arr[HART_COMMAND_3] = hart_slave_command_3_req;   // 读取动态变量和回路电流
    hart_command_ptr_arr[HART_COMMAND_6] = hart_slave_command_6_req;   // 写入轮训地址
    hart_command_ptr_arr[HART_COMMAND_8] = hart_slave_command_8_req;   // 读取动态变量分类
    hart_command_ptr_arr[HART_COMMAND_12] = hart_slave_command_12_req; // 读取消息
    hart_command_ptr_arr[HART_COMMAND_13] = hart_slave_command_13_req; // 读取标签、描述符、日期
    hart_command_ptr_arr[HART_COMMAND_15] = hart_slave_command_15_req; // 读取设备信息

    hart_command_ptr_arr[HART_COMMAND_17] = hart_slave_command_17_req; // 写入消息
    hart_command_ptr_arr[HART_COMMAND_18] = hart_slave_command_18_req; // 写标签、描述符、日期
    hart_command_ptr_arr[HART_COMMAND_20] = hart_slave_command_20_req; // 读取长标签
    hart_command_ptr_arr[HART_COMMAND_21] = hart_slave_command_21_req; // 读取与长标签关联的唯一标识符
    hart_command_ptr_arr[HART_COMMAND_22] = hart_slave_command_22_req; // 写长标签
    hart_command_ptr_arr[HART_COMMAND_38] = hart_slave_command_38_req; // 重置配置更改标志
    hart_command_ptr_arr[HART_COMMAND_48] = hart_slave_command_48_req; // 读取其他设备状态

    // hart_command_ptr_arr[HART_COMMAND_7] = hart_slave_command_7_req;   // 读取循环配置
    // hart_command_ptr_arr[HART_COMMAND_9] = hart_slave_command_9_req;   // 读取具有状态的设备变量
    // hart_command_ptr_arr[HART_COMMAND_11] = hart_slave_command_11_req; // 读取与标签关联的唯一标识符
    // hart_command_ptr_arr[HART_COMMAND_14] = hart_slave_command_14_req; // 读取主变量传感器信息
    // hart_command_ptr_arr[HART_COMMAND_16] = hart_slave_command_16_req; // 读取最终总装编号
    // hart_command_ptr_arr[HART_COMMAND_19] = hart_slave_command_19_req; // 编写总装编号

    // 常用命令
    hart_command_ptr_arr[HART_COMMAND_33] = hart_slave_command_33_req;   // 读取设备变量
    hart_command_ptr_arr[HART_COMMAND_39] = hart_slave_command_39_req;   // EEPROM控制
    hart_command_ptr_arr[HART_COMMAND_41] = hart_slave_command_41_req;   // 执行自检
    hart_command_ptr_arr[HART_COMMAND_42] = hart_slave_command_42_req;   // 执行设备重置
    hart_command_ptr_arr[HART_COMMAND_71] = hart_slave_command_71_req;   // 锁定装置
    hart_command_ptr_arr[HART_COMMAND_79] = hart_slave_command_79_req;   // 写入设备变量
    hart_command_ptr_arr[HART_COMMAND_89] = hart_slave_command_89_req;   // 设置实时时钟
    hart_command_ptr_arr[HART_COMMAND_90] = hart_slave_command_90_req;   // 读取实时时钟
    hart_command_ptr_arr[HART_COMMAND_512] = hart_slave_command_512_req; // 读取国家代码
    hart_command_ptr_arr[HART_COMMAND_513] = hart_slave_command_513_req; // 编写国家代码
    hart_command_ptr_arr[HART_COMMAND_516] = hart_slave_command_516_req; // 读取设备位置
    hart_command_ptr_arr[HART_COMMAND_517] = hart_slave_command_517_req; // 写入设备位置
    hart_command_ptr_arr[HART_COMMAND_518] = hart_slave_command_518_req; // 读取位置说明
    hart_command_ptr_arr[HART_COMMAND_519] = hart_slave_command_519_req; // 写入位置说明

    // hart_command_ptr_arr[HART_COMMAND_34] = hart_slave_command_34_req;   // 写入主变量阻尼值
    // hart_command_ptr_arr[HART_COMMAND_35] = hart_slave_command_35_req;   // 写入主变量范围值
    // hart_command_ptr_arr[HART_COMMAND_36] = hart_slave_command_36_req;   // 设置主变量上限值
    // hart_command_ptr_arr[HART_COMMAND_37] = hart_slave_command_37_req;   // 设置主变量下限值
    // hart_command_ptr_arr[HART_COMMAND_40] = hart_slave_command_40_req;   // 进入/退出固定电流模式
    // hart_command_ptr_arr[HART_COMMAND_43] = hart_slave_command_43_req;   // 设置主变量零
    // hart_command_ptr_arr[HART_COMMAND_44] = hart_slave_command_44_req;   // 编写主变量单元
    // hart_command_ptr_arr[HART_COMMAND_45] = hart_slave_command_45_req;   // 微调回路电流归零
    // hart_command_ptr_arr[HART_COMMAND_46] = hart_slave_command_46_req;   // 微调回路电流增益
    // hart_command_ptr_arr[HART_COMMAND_47] = hart_slave_command_47_req;   // 编写主变量传递函数
    // hart_command_ptr_arr[HART_COMMAND_49] = hart_slave_command_49_req;   // 写入主变量传感器序列号
    // hart_command_ptr_arr[HART_COMMAND_50] = hart_slave_command_50_req;   // 读取动态变量赋值
    // hart_command_ptr_arr[HART_COMMAND_51] = hart_slave_command_51_req;   // 编写动态变量赋值
    // hart_command_ptr_arr[HART_COMMAND_52] = hart_slave_command_52_req;   // 设置设备变量零
    // hart_command_ptr_arr[HART_COMMAND_53] = hart_slave_command_53_req;   // 写入设备变量单元
    // hart_command_ptr_arr[HART_COMMAND_54] = hart_slave_command_54_req;   // 读取设备变量信息
    // hart_command_ptr_arr[HART_COMMAND_55] = hart_slave_command_55_req;   // 写入设备可变阻尼值
    // hart_command_ptr_arr[HART_COMMAND_56] = hart_slave_command_56_req;   // 写入设备可变传感器序列号
    // hart_command_ptr_arr[HART_COMMAND_57] = hart_slave_command_57_req;   // 读取单位标签、描述符、日期
    // hart_command_ptr_arr[HART_COMMAND_58] = hart_slave_command_58_req;   // 编写单位标签、描述符、日期
    // hart_command_ptr_arr[HART_COMMAND_59] = hart_slave_command_59_req;   // 写入响应序码数
    // hart_command_ptr_arr[HART_COMMAND_60] = hart_slave_command_60_req;   // 读取模拟通道和范围百分比
    // hart_command_ptr_arr[HART_COMMAND_61] = hart_slave_command_61_req;   // 读取动态变量和主变量模拟通道
    // hart_command_ptr_arr[HART_COMMAND_62] = hart_slave_command_62_req;   // 读取模拟通道
    // hart_command_ptr_arr[HART_COMMAND_63] = hart_slave_command_63_req;   // 读取模拟通道信息
    // hart_command_ptr_arr[HART_COMMAND_64] = hart_slave_command_64_req;   // 写入模拟通道附加阻尼值
    // hart_command_ptr_arr[HART_COMMAND_65] = hart_slave_command_65_req;   // 写入模拟通道范围值
    // hart_command_ptr_arr[HART_COMMAND_66] = hart_slave_command_66_req;   // 进入/退出固定模拟通道模式
    // hart_command_ptr_arr[HART_COMMAND_67] = hart_slave_command_67_req;   // 调整模拟通道零
    // hart_command_ptr_arr[HART_COMMAND_68] = hart_slave_command_68_req;   // 微调模拟通道增益
    // hart_command_ptr_arr[HART_COMMAND_69] = hart_slave_command_69_req;   // 写入模拟通道传递函数
    // hart_command_ptr_arr[HART_COMMAND_70] = hart_slave_command_70_req;   // 读取模拟通道端点值
    // hart_command_ptr_arr[HART_COMMAND_72] = hart_slave_command_72_req;   // 呼叫
    // hart_command_ptr_arr[HART_COMMAND_73] = hart_slave_command_73_req;   // 查找设备
    // hart_command_ptr_arr[HART_COMMAND_74] = hart_slave_command_74_req;   // 读取I/O系统功能
    // hart_command_ptr_arr[HART_COMMAND_75] = hart_slave_command_75_req;   // 轮询子设备
    // hart_command_ptr_arr[HART_COMMAND_76] = hart_slave_command_76_req;   // 读锁定设备状态
    // hart_command_ptr_arr[HART_COMMAND_80] = hart_slave_command_80_req;   // 读取设备可变微调点
    // hart_command_ptr_arr[HART_COMMAND_81] = hart_slave_command_81_req;   // 读取设备变量调整指南
    // hart_command_ptr_arr[HART_COMMAND_82] = hart_slave_command_82_req;   // 写入设备可变微调点
    // hart_command_ptr_arr[HART_COMMAND_83] = hart_slave_command_83_req;   // 重置设备变量调整
    // hart_command_ptr_arr[HART_COMMAND_84] = hart_slave_command_84_req;   // 读取子设备标识摘要
    // hart_command_ptr_arr[HART_COMMAND_85] = hart_slave_command_85_req;   // 读取I/O通道统计信息
    // hart_command_ptr_arr[HART_COMMAND_86] = hart_slave_command_86_req;   // 读取子设备统计信息
    // hart_command_ptr_arr[HART_COMMAND_87] = hart_slave_command_87_req;   // 写入I/O系统主模式
    // hart_command_ptr_arr[HART_COMMAND_88] = hart_slave_command_88_req;   // 写入I/O系统重试计数
    // hart_command_ptr_arr[HART_COMMAND_91] = hart_slave_command_91_req;   // 读取趋势配置
    // hart_command_ptr_arr[HART_COMMAND_92] = hart_slave_command_92_req;   // 写入趋势配置
    // hart_command_ptr_arr[HART_COMMAND_93] = hart_slave_command_93_req;   // 读取趋势
    // hart_command_ptr_arr[HART_COMMAND_94] = hart_slave_command_94_req;   // 读取I/O系统客户端通信统计信息
    // hart_command_ptr_arr[HART_COMMAND_95] = hart_slave_command_95_req;   // 读取设备通信统计信息
    // hart_command_ptr_arr[HART_COMMAND_96] = hart_slave_command_96_req;   // 读取同步操作
    // hart_command_ptr_arr[HART_COMMAND_97] = hart_slave_command_97_req;   // 配置同步操作
    // hart_command_ptr_arr[HART_COMMAND_98] = hart_slave_command_98_req;   // 读取命令操作
    // hart_command_ptr_arr[HART_COMMAND_99] = hart_slave_command_99_req;   // 配置命令操作
    // hart_command_ptr_arr[HART_COMMAND_100] = hart_slave_command_100_req; // 写入主变量报警码
    // hart_command_ptr_arr[HART_COMMAND_103] = hart_slave_command_103_req; // 写入突发周期
    // hart_command_ptr_arr[HART_COMMAND_104] = hart_slave_command_104_req; // 写入突发触发器
    // hart_command_ptr_arr[HART_COMMAND_105] = hart_slave_command_105_req; // 读取突发模式配置
    // hart_command_ptr_arr[HART_COMMAND_107] = hart_slave_command_107_req; // 写入突发设备变量V5
    // hart_command_ptr_arr[HART_COMMAND_514] = hart_slave_command_514_req; // 注册事件管理器
    // hart_command_ptr_arr[HART_COMMAND_515] = hart_slave_command_515_req; // 读取事件管理器注册状态
    // hart_command_ptr_arr[HART_COMMAND_520] = hart_slave_command_520_req; // 读取进程单元标签
    // hart_command_ptr_arr[HART_COMMAND_521] = hart_slave_command_521_req; // 写入进程单元标记
    // hart_command_ptr_arr[HART_COMMAND_522] = hart_slave_command_522_req; // 写入体积流分类
    // hart_command_ptr_arr[HART_COMMAND_523] = hart_slave_command_523_req; // 读取精简状态映射数组
    // hart_command_ptr_arr[HART_COMMAND_524] = hart_slave_command_524_req; // 写入精简状态映射
    // hart_command_ptr_arr[HART_COMMAND_525] = hart_slave_command_525_req; // 重置精简状态图
    // hart_command_ptr_arr[HART_COMMAND_526] = hart_slave_command_526_req; // 写入状态模拟模式
    // hart_command_ptr_arr[HART_COMMAND_527] = hart_slave_command_527_req; // 模拟状态位
    // hart_command_ptr_arr[HART_COMMAND_528] = hart_slave_command_528_req; // 读取子设备分配列表信息
    // hart_command_ptr_arr[HART_COMMAND_529] = hart_slave_command_529_req; // 读取子设备分配
    // hart_command_ptr_arr[HART_COMMAND_530] = hart_slave_command_530_req; // 写入子设备分配
    // hart_command_ptr_arr[HART_COMMAND_531] = hart_slave_command_531_req; // 将实时列表传输到分配列表
    // hart_command_ptr_arr[HART_COMMAND_532] = hart_slave_command_532_req; // 读取客户端订阅摘要
    // hart_command_ptr_arr[HART_COMMAND_533] = hart_slave_command_533_req; // 写入客户端订阅标志
    hart_command_ptr_arr[HART_COMMAND_534] = hart_slave_command_534_req; // 读取设备变量命令代码
    // hart_command_ptr_arr[HART_COMMAND_535] = hart_slave_command_535_req; // 写入模拟通道端点值
    // hart_command_ptr_arr[HART_COMMAND_536] = hart_slave_command_536_req; // 写入应用时间操作
    // hart_command_ptr_arr[HART_COMMAND_537] = hart_slave_command_537_req; // 读取应用时间操作
    // hart_command_ptr_arr[HART_COMMAND_538] = hart_slave_command_538_req; // 读取HART-IP服务器端口
    // hart_command_ptr_arr[HART_COMMAND_539] = hart_slave_command_539_req; // 写入HART-IP UDP端口
    // hart_command_ptr_arr[HART_COMMAND_540] = hart_slave_command_540_req; // 写入HART-IP TCP端口
    // hart_command_ptr_arr[HART_COMMAND_541] = hart_slave_command_541_req; // 写入客户端PAKE密码
    // hart_command_ptr_arr[HART_COMMAND_542] = hart_slave_command_542_req; // 写入客户端预共享密钥
    // hart_command_ptr_arr[HART_COMMAND_543] = hart_slave_command_543_req; // 读取系统日志服务器主机名和端口
    // hart_command_ptr_arr[HART_COMMAND_544] = hart_slave_command_544_req; // 写入系统日志端口
    // hart_command_ptr_arr[HART_COMMAND_545] = hart_slave_command_545_req; // 写入系统日志服务器主机名
    // hart_command_ptr_arr[HART_COMMAND_546] = hart_slave_command_546_req; // 写入系统日志服务器预共享密钥
    // hart_command_ptr_arr[HART_COMMAND_547] = hart_slave_command_547_req; // 写入系统日志服务器PAKE密码

    // 暂不支持指令
    // hart_command_ptr_arr[HART_COMMAND_77] = hart_slave_command_77_req;   // 向子设备发送命令
    // hart_command_ptr_arr[HART_COMMAND_78] = hart_slave_command_78_req;   // 读取聚合命令
    // hart_command_ptr_arr[HART_COMMAND_101] = hart_slave_command_101_req; // 读取子设备到突发消息映射
    // hart_command_ptr_arr[HART_COMMAND_102] = hart_slave_command_102_req; // 将子设备映射到突发信息
    // hart_command_ptr_arr[HART_COMMAND_106] = hart_slave_command_106_req; // 刷新延迟响应
    // hart_command_ptr_arr[HART_COMMAND_108] = hart_slave_command_108_req; // 写入突发模式命令编号V5
    // hart_command_ptr_arr[HART_COMMAND_109] = hart_slave_command_109_req; // 突发模式控制V5
    // hart_command_ptr_arr[HART_COMMAND_110] = hart_slave_command_110_req; // 读取所有动态变量V5
    // hart_command_ptr_arr[HART_COMMAND_111] = hart_slave_command_111_req; // 转移服务控制
    // hart_command_ptr_arr[HART_COMMAND_112] = hart_slave_command_112_req; // 传输服务
    // hart_command_ptr_arr[HART_COMMAND_113] = hart_slave_command_113_req; // 捕获设备变量
    // hart_command_ptr_arr[HART_COMMAND_114] = hart_slave_command_114_req; // 读取捕获的设备变量
    // hart_command_ptr_arr[HART_COMMAND_115] = hart_slave_command_115_req; // 读取事件通知摘要
    // hart_command_ptr_arr[HART_COMMAND_116] = hart_slave_command_116_req; // 写入事件通知位掩码
    // hart_command_ptr_arr[HART_COMMAND_117] = hart_slave_command_117_req; // 写入事件通知时序
    // hart_command_ptr_arr[HART_COMMAND_118] = hart_slave_command_118_req; // 事件通知控制
    // hart_command_ptr_arr[HART_COMMAND_119] = hart_slave_command_119_req; // 确认事件通知

    // 暂不支持指令 end

    hart_slave_req_init_user(); // 用户自定义命令
}
